308 {
309 const auto lengths = feature_lengths(samples.size());
310 const uint32_t frames = lengths.back();
313
314 const auto front_at = [&](
size_t slot) {
return front.address(
address(WeightsFront), slot); };
315 const auto block_at = [&](uint32_t block,
size_t slot) {
return blocks[block].address(
address(WeightsBlock0 + block), slot); };
316
317 std::vector<DependencyStage> stages;
318 const auto dense = [&](uint64_t src, uint32_t in, uint64_t weight, uint64_t bias, uint64_t dst, uint32_t out,
Activation activation = Activation::None) {
319 stages.push_back(
TensorKernels::conv1d_stage({ .c_in = in, .c_out = out, .kernel = 1, .activation = activation }, src, weight, bias, dst, 1, frames));
320 };
321 const auto layer_norm = [&](uint64_t data, uint32_t channels, uint64_t weight, uint64_t bias) {
324 };
325
327 auto length = static_cast<uint32_t>(samples.size());
328 for (uint32_t i = 0; i < k_feature_layers; ++i) {
329 const uint64_t dst =
address(i % 2 == 0 ? WideA : WideB);
331 if (i == 0) {
334 dst, k_features, lengths[0], 1, NormAffine::Outer, Activation::Gelu));
335 }
336 features = dst;
337 length = lengths[i];
338 }
339
340 const uint64_t hidden =
address(Hidden);
341 layer_norm(features, k_features, front_at(ProjectionNormWeight), front_at(ProjectionNormBias));
342 dense(features, k_features, front_at(ProjectionWeight), front_at(ProjectionBias), hidden, k_width);
343
345 { .c_in = k_width, .c_out = k_width, .kernel = k_position_kernel, .groups = k_position_groups, .pad = k_position_kernel / 2, .trim = 1, .activation = Activation::Gelu },
346 hidden,
address(WeightsPosition), front_at(PositionBias),
address(Positional), 1, frames));
348 layer_norm(hidden, k_width, front_at(EncoderNormWeight), front_at(EncoderNormBias));
349
350 const float score_scale = 1.0F / std::sqrt(static_cast<float>(k_head_width));
351 for (uint32_t block = 0; block < k_blocks; ++block) {
352 dense(hidden, k_width, block_at(block, QueryWeight), block_at(block, QueryBias),
address(Query), k_width);
353 dense(hidden, k_width, block_at(block, KeyWeight), block_at(block, KeyBias),
address(Key), k_width);
354 dense(hidden, k_width, block_at(block, ValueWeight), block_at(block, ValueBias),
address(Value), k_width);
358 dense(
address(Query), k_width, block_at(block, OutputWeight), block_at(block, OutputBias),
address(Key), k_width);
360 layer_norm(hidden, k_width, block_at(block, NormWeight), block_at(block, NormBias));
361
362 dense(hidden, k_width, block_at(block, ExpandWeight), block_at(block, ExpandBias),
address(Expanded), k_expanded, Activation::Gelu);
363 dense(
address(Expanded), k_expanded, block_at(block, ReduceWeight), block_at(block, ReduceBias),
address(Key), k_width);
365 layer_norm(hidden, k_width, block_at(block, FinalNormWeight), block_at(block, FinalNormBias));
366 }
367
368 dense(hidden, k_width, front_at(HeadWeight), front_at(HeadBias),
address(Posterior), k_classes);
370
371 context->record_stages(stages);
373
374 std::vector<float> rows(static_cast<size_t>(k_classes) * frames);
375 context->download_shared(0, Posterior, rows.data(), rows.size() *
sizeof(
float));
376 return frame_major(rows, k_classes, frames);
377 }
DependencyStage softmax_stage(uint64_t data, uint32_t outer, uint32_t extent, uint32_t inner)
One nn_softmax dispatch: softmax of a tensor [outer, extent, inner] along extent, in place.
DependencyStage grouped_conv1d_stage(const GroupedConv1d &layer, uint64_t src, uint64_t weights, uint64_t bias, uint64_t dst, uint32_t batch, uint32_t t_in)
One nn_conv1d_grouped dispatch: [batch, c_in, t_in] to [batch, c_out, grouped_conv1d_length].
DependencyStage add_stage(uint64_t a, uint64_t b, uint64_t dst, uint32_t count)
One nn_add dispatch: the element-wise sum of two sequences of count floats.
DependencyStage normalize_apply_stage(uint64_t src, uint64_t stats, uint64_t weight, uint64_t bias, uint64_t dst, uint32_t outer, uint32_t extent, uint32_t inner, NormAffine affine, Activation activation=Activation::None)
The nn_normalize dispatch that writes (x - mean) * scale from the measures of normalize_stats_stage.
DependencyStage normalize_stats_stage(uint64_t src, uint64_t stats, uint32_t outer, uint32_t extent, uint32_t inner, float epsilon)
The nn_normalize dispatch that measures every row of a tensor [outer, extent, inner] along extent.
DependencyStage attention_scores_stage(uint64_t q, uint64_t k, uint64_t scores, uint32_t heads, uint32_t dim, uint32_t time, float scale)
One nn_attention_scores dispatch: scale times the dot product of every query with every key,...
DependencyStage attention_mix_stage(uint64_t weights, uint64_t v, uint64_t dst, uint32_t heads, uint32_t dim, uint32_t time)
One nn_attention_mix dispatch: the values of every position mixed by each query's attention weights.
DependencyStage conv1d_stage(const Conv1d &layer, uint64_t src, uint64_t weights, uint64_t bias, uint64_t dst, uint32_t batch, uint32_t t_in)
One nn_conv1d dispatch: [batch, c_in, t_in] to [batch, c_out, conv1d_length].
Activation
Output activation of a layer.
static constexpr DomainSpec Audio
Domain constant for Audio domain.
std::unique_ptr< ShaderExecutionContext<> > context
void upload_normalised(std::span< const float > samples)
uint64_t address(uint32_t buffer) const
void ensure_capacity(size_t samples, const std::array< uint32_t, k_feature_layers > &lengths)
TensorKernels::PackedWeights front
std::array< TensorKernels::PackedWeights, k_blocks > blocks