Initial commit

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.sentis filter=lfs diff=lfs merge=lfs -text

CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] - 2026-10-22
+### Added
+- Initial package: `CedTiny` Unity Inference Engine (Sentis) audio tagger wrapper (in-graph log-mel frontend, 527 AudioSet classes + embedding, resampling, sliding-window streaming, sync + async readback); FP32 model weights and AudioSet labels under `Models~`.

CHANGELOG.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ab3bd0bc4f724aac98d27c51e484d44d
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LICENSE.md

@@ -0,0 +1,21 @@
+# sentis-ced-tiny License
+
+This package's wrapper code (`Runtime/`) is licensed under the Apache License 2.0 (below).
+The bundled model weights (`Models~/ced_tiny_fp32.sentis`) are derived from CED by Heinrich Dinkel et al. (https://github.com/RicherMans/CED, https://huggingface.co/mispeech/ced-tiny)
+and remain under the Apache License 2.0. Modifications to the weights file: log-mel frontend prepended as a fixed-basis
+convolution, outputs exposed as sigmoid scores + clip embedding; converted to the Unity Sentis format.
+`Models~/audioset_labels.txt` lists the AudioSet ontology class names (Google, CC BY 4.0).
+
+Copyright (c) 2026 Sky Kim
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

LICENSE.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 780a3fc47c444291b8b8aad36e9cc74f
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Models~/audioset_labels.txt

@@ -0,0 +1,527 @@
+Speech
+Male speech, man speaking
+Female speech, woman speaking
+Child speech, kid speaking
+Conversation
+Narration, monologue
+Babbling
+Speech synthesizer
+Shout
+Bellow
+Whoop
+Yell
+Battle cry
+Children shouting
+Screaming
+Whispering
+Laughter
+Baby laughter
+Giggle
+Snicker
+Belly laugh
+Chuckle, chortle
+Crying, sobbing
+Baby cry, infant cry
+Whimper
+Wail, moan
+Sigh
+Singing
+Choir
+Yodeling
+Chant
+Mantra
+Male singing
+Female singing
+Child singing
+Synthetic singing
+Rapping
+Humming
+Groan
+Grunt
+Whistling
+Breathing
+Wheeze
+Snoring
+Gasp
+Pant
+Snort
+Cough
+Throat clearing
+Sneeze
+Sniff
+Run
+Shuffle
+Walk, footsteps
+Chewing, mastication
+Biting
+Gargling
+Stomach rumble
+Burping, eructation
+Hiccup
+Fart
+Hands
+Finger snapping
+Clapping
+Heart sounds, heartbeat
+Heart murmur
+Cheering
+Applause
+Chatter
+Crowd
+Hubbub, speech noise, speech babble
+Children playing
+Animal
+Domestic animals, pets
+Dog
+Bark
+Yip
+Howl
+Bow-wow
+Growling
+Whimper (dog)
+Cat
+Purr
+Meow
+Hiss
+Caterwaul
+Livestock, farm animals, working animals
+Horse
+Clip-clop
+Neigh, whinny
+Cattle, bovinae
+Moo
+Cowbell
+Pig
+Oink
+Goat
+Bleat
+Sheep
+Fowl
+Chicken, rooster
+Cluck
+Crowing, cock-a-doodle-doo
+Turkey
+Gobble
+Duck
+Quack
+Goose
+Honk
+Wild animals
+Roaring cats (lions, tigers)
+Roar
+Bird
+Bird vocalization, bird call, bird song
+Chirp, tweet
+Squawk
+Pigeon, dove
+Coo
+Crow
+Caw
+Owl
+Hoot
+Bird flight, flapping wings
+Canidae, dogs, wolves
+Rodents, rats, mice
+Mouse
+Patter
+Insect
+Cricket
+Mosquito
+Fly, housefly
+Buzz
+Bee, wasp, etc.
+Frog
+Croak
+Snake
+Rattle
+Whale vocalization
+Music
+Musical instrument
+Plucked string instrument
+Guitar
+Electric guitar
+Bass guitar
+Acoustic guitar
+Steel guitar, slide guitar
+Tapping (guitar technique)
+Strum
+Banjo
+Sitar
+Mandolin
+Zither
+Ukulele
+Keyboard (musical)
+Piano
+Electric piano
+Organ
+Electronic organ
+Hammond organ
+Synthesizer
+Sampler
+Harpsichord
+Percussion
+Drum kit
+Drum machine
+Drum
+Snare drum
+Rimshot
+Drum roll
+Bass drum
+Timpani
+Tabla
+Cymbal
+Hi-hat
+Wood block
+Tambourine
+Rattle (instrument)
+Maraca
+Gong
+Tubular bells
+Mallet percussion
+Marimba, xylophone
+Glockenspiel
+Vibraphone
+Steelpan
+Orchestra
+Brass instrument
+French horn
+Trumpet
+Trombone
+Bowed string instrument
+String section
+Violin, fiddle
+Pizzicato
+Cello
+Double bass
+Wind instrument, woodwind instrument
+Flute
+Saxophone
+Clarinet
+Harp
+Bell
+Church bell
+Jingle bell
+Bicycle bell
+Tuning fork
+Chime
+Wind chime
+Change ringing (campanology)
+Harmonica
+Accordion
+Bagpipes
+Didgeridoo
+Shofar
+Theremin
+Singing bowl
+Scratching (performance technique)
+Pop music
+Hip hop music
+Beatboxing
+Rock music
+Heavy metal
+Punk rock
+Grunge
+Progressive rock
+Rock and roll
+Psychedelic rock
+Rhythm and blues
+Soul music
+Reggae
+Country
+Swing music
+Bluegrass
+Funk
+Folk music
+Middle Eastern music
+Jazz
+Disco
+Classical music
+Opera
+Electronic music
+House music
+Techno
+Dubstep
+Drum and bass
+Electronica
+Electronic dance music
+Ambient music
+Trance music
+Music of Latin America
+Salsa music
+Flamenco
+Blues
+Music for children
+New-age music
+Vocal music
+A capella
+Music of Africa
+Afrobeat
+Christian music
+Gospel music
+Music of Asia
+Carnatic music
+Music of Bollywood
+Ska
+Traditional music
+Independent music
+Song
+Background music
+Theme music
+Jingle (music)
+Soundtrack music
+Lullaby
+Video game music
+Christmas music
+Dance music
+Wedding music
+Happy music
+Funny music
+Sad music
+Tender music
+Exciting music
+Angry music
+Scary music
+Wind
+Rustling leaves
+Wind noise (microphone)
+Thunderstorm
+Thunder
+Water
+Rain
+Raindrop
+Rain on surface
+Stream
+Waterfall
+Ocean
+Waves, surf
+Steam
+Gurgling
+Fire
+Crackle
+Vehicle
+Boat, Water vehicle
+Sailboat, sailing ship
+Rowboat, canoe, kayak
+Motorboat, speedboat
+Ship
+Motor vehicle (road)
+Car
+Vehicle horn, car horn, honking
+Toot
+Car alarm
+Power windows, electric windows
+Skidding
+Tire squeal
+Car passing by
+Race car, auto racing
+Truck
+Air brake
+Air horn, truck horn
+Reversing beeps
+Ice cream truck, ice cream van
+Bus
+Emergency vehicle
+Police car (siren)
+Ambulance (siren)
+Fire engine, fire truck (siren)
+Motorcycle
+Traffic noise, roadway noise
+Rail transport
+Train
+Train whistle
+Train horn
+Railroad car, train wagon
+Train wheels squealing
+Subway, metro, underground
+Aircraft
+Aircraft engine
+Jet engine
+Propeller, airscrew
+Helicopter
+Fixed-wing aircraft, airplane
+Bicycle
+Skateboard
+Engine
+Light engine (high frequency)
+Dental drill, dentist's drill
+Lawn mower
+Chainsaw
+Medium engine (mid frequency)
+Heavy engine (low frequency)
+Engine knocking
+Engine starting
+Idling
+Accelerating, revving, vroom
+Door
+Doorbell
+Ding-dong
+Sliding door
+Slam
+Knock
+Tap
+Squeak
+Cupboard open or close
+Drawer open or close
+Dishes, pots, and pans
+Cutlery, silverware
+Chopping (food)
+Frying (food)
+Microwave oven
+Blender
+Water tap, faucet
+Sink (filling or washing)
+Bathtub (filling or washing)
+Hair dryer
+Toilet flush
+Toothbrush
+Electric toothbrush
+Vacuum cleaner
+Zipper (clothing)
+Keys jangling
+Coin (dropping)
+Scissors
+Electric shaver, electric razor
+Shuffling cards
+Typing
+Typewriter
+Computer keyboard
+Writing
+Alarm
+Telephone
+Telephone bell ringing
+Ringtone
+Telephone dialing, DTMF
+Dial tone
+Busy signal
+Alarm clock
+Siren
+Civil defense siren
+Buzzer
+Smoke detector, smoke alarm
+Fire alarm
+Foghorn
+Whistle
+Steam whistle
+Mechanisms
+Ratchet, pawl
+Clock
+Tick
+Tick-tock
+Gears
+Pulleys
+Sewing machine
+Mechanical fan
+Air conditioning
+Cash register
+Printer
+Camera
+Single-lens reflex camera
+Tools
+Hammer
+Jackhammer
+Sawing
+Filing (rasp)
+Sanding
+Power tool
+Drill
+Explosion
+Gunshot, gunfire
+Machine gun
+Fusillade
+Artillery fire
+Cap gun
+Fireworks
+Firecracker
+Burst, pop
+Eruption
+Boom
+Wood
+Chop
+Splinter
+Crack
+Glass
+Chink, clink
+Shatter
+Liquid
+Splash, splatter
+Slosh
+Squish
+Drip
+Pour
+Trickle, dribble
+Gush
+Fill (with liquid)
+Spray
+Pump (liquid)
+Stir
+Boiling
+Sonar
+Arrow
+Whoosh, swoosh, swish
+Thump, thud
+Thunk
+Electronic tuner
+Effects unit
+Chorus effect
+Basketball bounce
+Bang
+Slap, smack
+Whack, thwack
+Smash, crash
+Breaking
+Bouncing
+Whip
+Flap
+Scratch
+Scrape
+Rub
+Roll
+Crushing
+Crumpling, crinkling
+Tearing
+Beep, bleep
+Ping
+Ding
+Clang
+Squeal
+Creak
+Rustle
+Whir
+Clatter
+Sizzle
+Clicking
+Clickety-clack
+Rumble
+Plop
+Jingle, tinkle
+Hum
+Zing
+Boing
+Crunch
+Silence
+Sine wave
+Harmonic
+Chirp tone
+Sound effect
+Pulse
+Inside, small room
+Inside, large room or hall
+Inside, public space
+Outside, urban or manmade
+Outside, rural or natural
+Reverberation
+Echo
+Noise
+Environmental noise
+Static
+Mains hum
+Distortion
+Sidetone
+Cacophony
+White noise
+Pink noise
+Throbbing
+Vibration
+Television
+Radio
+Field recording

Models~/ced_tiny_fp32.sentis

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e725666b9e3e7213d8f03c3b5c9fc00dbfe951f33ab3599c53758bbc7fc00fd6
+size 23204224

README.md

@@ -0,0 +1,76 @@
+---
+license: apache-2.0
+library_name: unity-sentis
+tags:
+  - unity
+  - sentis
+  - on-device
+  - audio-classification
+  - audio-tagging
+  - sound-event-detection
+  - audioset
+---
+
+# sentis-ced-tiny
+
+CED-Tiny (Consistent Ensemble Distillation ViT) AudioSet audio tagger converted to **Unity Inference Engine (Sentis)** FP32. Recognizes 527 AudioSet sound classes (animals, alarms,
+vehicles, household and environmental sounds, music, human non-speech sounds, ...) from a raw mono waveform, and returns a
+192-d embedding usable for your own classes.
+
+## Files
+
+```
+ced_tiny_fp32.sentis   # waveform [1, 48000] (16000 Hz mono, 3 s) -> scores [1, 527] (sigmoid), embedding [1, 192]
+audioset_labels.txt   # 527 AudioSet display names, index order of the scores
+CedTiny.cs   # self-contained Unity Sentis inference
+```
+
+## Inference
+
+The log-mel frontend is baked into the model (STFT as a fixed-basis Conv1d), so the whole pipeline waveform -> scores runs
+in one Sentis graph on CPU or GPU, with no feature extraction in C#. `CedTiny` resamples any input rate to 16000 Hz,
+classifies the last 3 s, and also offers a sliding-window streaming buffer for microphone input.
+
+A complete self-contained implementation lives in [`CedTiny.cs`](Runtime/CedTiny.cs). Minimal usage:
+
+```csharp
+var tagger = new CedTiny(BackendType.GPUCompute);
+tagger.Load(modelRoot);              // folder holding ced_tiny_fp32.sentis + audioset_labels.txt
+tagger.Warmup();
+
+// one-shot: an AudioClip (any sample rate / channel count)
+var data = new float[clip.samples * clip.channels];
+clip.GetData(data, 0);
+var scores = tagger.Classify(CedTiny.ToMono(data, clip.channels), clip.frequency);
+foreach (var p in tagger.Top(scores, k: 5, minScore: 0.1f))
+    Debug.Log($"{p.Label}: {p.Score:F2}");
+
+// streaming: feed microphone chunks, classify the latest window every 0.25-0.5 s
+tagger.Push(micChunk, micSampleRate);
+var latest = await tagger.ClassifyLatestAsync();
+```
+
+> Scores are independent sigmoid probabilities (multi-label), so several classes can be high at once; threshold per class
+> (0.1-0.3 is a common starting point). `tagger.Embedding` holds the 192-d embedding of the last call for training a small
+> classifier on your own sound classes.
+
+## Conversion notes
+
+- Source: [mispeech/ced-tiny](https://huggingface.co/mispeech/ced-tiny) (`model.safetensors`, re-exported from PyTorch; the repo's own `model.onnx` is int8-quantized and does not import into Sentis).
+- Architecture: ViT (12 layers, dim 192, 3 heads, 16x16 patches) trained with consistent ensemble distillation on AudioSet; 5.5M parameters.
+- Frontend: 64-bin log-mel, 16 kHz, n_fft 512 / window 512 / hop 160, power to dB with `top_db = 120` (CED `CedFeatureExtractor`). Reimplemented as a Conv1d with a windowed DFT basis + mel matrix taken from the original library,
+  so no STFT / complex op is needed; it matches the original feature extractor.
+- Exported with `torch.onnx.export` (opset 17) as one waveform -> (scores, embedding) graph at a fixed 3 s window
+  and imported into Sentis 2.6.1.
+- The exported graph matches the original PyTorch pipeline in ONNX Runtime, and Unity Sentis output matches ONNX Runtime
+  on the same input (CPU and GPUCompute).
+- CED splits inputs longer than 10 s into chunks; the 3 s window used here stays within one chunk, so the
+  graph is the plain ViT forward (time positional embeddings for the first 18 patches).
+- The model was trained on 10 s clips: windows shorter than ~2 s lose noticeable accuracy, so keep the 3 s
+  window (`Push` + `ClassifyLatest`) rather than classifying very short snippets.
+
+## License & attribution
+
+Apache License 2.0. Converted from CED by Heinrich Dinkel et al. (https://github.com/RicherMans/CED, https://huggingface.co/mispeech/ced-tiny).
+Paper: [CED: Consistent ensemble distillation for audio tagging](https://arxiv.org/abs/2308.11957) (ICASSP 2024).
+AudioSet class names: [AudioSet ontology](https://research.google.com/audioset/) (CC BY 4.0).

README.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b10799c7ab7f40588ec407a428b39063
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f8dfa59f676344dbb0314f7321225c44
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/CedTiny.cs

@@ -0,0 +1,200 @@
+// CED-Tiny (Consistent Ensemble Distillation ViT) AudioSet audio tagger. Self-contained Unity Sentis inference.
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using Unity.InferenceEngine;
+using UnityEngine;
+
+namespace SentisModels
+{
+// Mono waveform -> 527 AudioSet class probabilities (multi-label: independent sigmoids, they do not sum to 1) and a
+// 192-d clip embedding. The log-mel frontend (STFT as a fixed-basis Conv1d) is baked into the model, so the input is
+// the raw 16000 Hz waveform in [-1, 1]; one inference covers a 3 s window. Other sample rates are resampled here.
+public sealed class CedTiny : IDisposable
+{
+    public const int SampleRate = 16000;
+    public const int WindowSamples = 48000;
+    public const int ClassCount = 527;
+    public const int EmbeddingSize = 192;
+    const string DefaultModelFile = "ced_tiny_fp32.sentis";
+    const string DefaultLabelFile = "audioset_labels.txt";
+
+    public struct Prediction
+    {
+        public int Index;       // AudioSet class index (ontology order, class_labels_indices.csv)
+        public string Label;
+        public float Score;     // sigmoid probability
+    }
+
+    readonly BackendType m_BackendType;
+
+    Worker m_Worker;
+    Tensor<float> m_InputTensor;
+    string[] m_Labels;
+    readonly float[] m_Window = new float[WindowSamples];
+    readonly float[] m_Stream = new float[WindowSamples];   // sliding buffer for Push / ClassifyLatest
+
+    // Embedding of the most recent Classify call (penultimate features; use for your own classes / similarity).
+    public float[] Embedding { get; } = new float[EmbeddingSize];
+    public IReadOnlyList<string> Labels => m_Labels;
+
+    public CedTiny(BackendType backendType = BackendType.GPUCompute)
+    {
+        m_BackendType = backendType == BackendType.GPUCompute && !SystemInfo.supportsComputeShaders
+            ? BackendType.CPU
+            : backendType;
+    }
+
+    public bool IsLoaded => m_Worker != null;
+
+    // modelRoot: absolute path to the folder holding ced_tiny_fp32.sentis and audioset_labels.txt.
+    public void Load(string modelRoot, string modelFile = DefaultModelFile)
+    {
+        Load(ModelLoader.Load(Path.Combine(modelRoot, modelFile)), File.ReadAllLines(Path.Combine(modelRoot, DefaultLabelFile)));
+    }
+
+    // For platforms where the files must be read as bytes / text (e.g. Android StreamingAssets).
+    public void Load(byte[] modelBytes, string labelsText)
+    {
+        using var stream = new MemoryStream(modelBytes);
+        Load(ModelLoader.Load(stream), labelsText.Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries));
+    }
+
+    void Load(Model model, string[] labels)
+    {
+        if (labels.Length != ClassCount)
+            throw new ArgumentException($"expected {ClassCount} labels, got {labels.Length}");
+        DisposeResources();
+        m_Labels = labels;
+        m_Worker = new Worker(model, m_BackendType);
+        m_InputTensor = new Tensor<float>(new TensorShape(1, WindowSamples));
+        Array.Clear(m_Stream, 0, m_Stream.Length);
+    }
+
+    // One silent pass so the first real call doesn't pay shader compilation / allocation.
+    public void Warmup()
+    {
+        Classify(new float[WindowSamples]);
+    }
+
+    // samples: mono PCM at sampleRate. The LAST 3 s are classified (zero-padded in front when shorter).
+    public float[] Classify(float[] samples, int sampleRate = SampleRate)
+    {
+        Schedule(samples, sampleRate);
+        return Read();
+    }
+
+    // Async readback variant; prefer this for per-frame use on GPU backends (no main-thread stall).
+    public async Task<float[]> ClassifyAsync(float[] samples, int sampleRate = SampleRate)
+    {
+        Schedule(samples, sampleRate);
+        using var scores = await (m_Worker.PeekOutput("scores") as Tensor<float>).ReadbackAndCloneAsync();
+        using var embedding = await (m_Worker.PeekOutput("embedding") as Tensor<float>).ReadbackAndCloneAsync();
+        embedding.DownloadToArray().CopyTo(Embedding, 0);
+        return scores.DownloadToArray();
+    }
+
+    // Streaming: append new microphone / clip samples (mono, any rate) to the sliding window.
+    public void Push(float[] samples, int sampleRate = SampleRate)
+    {
+        var x = sampleRate == SampleRate ? samples : Resample(samples, sampleRate, SampleRate);
+        if (x.Length >= WindowSamples)
+        {
+            Array.Copy(x, x.Length - WindowSamples, m_Stream, 0, WindowSamples);
+            return;
+        }
+        Array.Copy(m_Stream, x.Length, m_Stream, 0, WindowSamples - x.Length);
+        Array.Copy(x, 0, m_Stream, WindowSamples - x.Length, x.Length);
+    }
+
+    // Classifies the last 3 s pushed with Push (call e.g. every 0.25-0.5 s for a sliding window).
+    public float[] ClassifyLatest() => Classify(m_Stream);
+
+    public Task<float[]> ClassifyLatestAsync() => ClassifyAsync(m_Stream);
+
+    // Highest-scoring classes, best first.
+    public List<Prediction> Top(float[] scores, int k = 5, float minScore = 0f)
+    {
+        var order = new int[scores.Length];
+        for (var i = 0; i < order.Length; i++)
+            order[i] = i;
+        Array.Sort(order, (a, b) => scores[b].CompareTo(scores[a]));
+        var result = new List<Prediction>();
+        for (var i = 0; i < order.Length && result.Count < k; i++)
+        {
+            if (scores[order[i]] < minScore)
+                break;
+            result.Add(new Prediction { Index = order[i], Label = m_Labels[order[i]], Score = scores[order[i]] });
+        }
+        return result;
+    }
+
+    // Average the channels of interleaved PCM (AudioClip.GetData / Microphone data).
+    public static float[] ToMono(float[] interleaved, int channels)
+    {
+        if (channels <= 1)
+            return interleaved;
+        var mono = new float[interleaved.Length / channels];
+        for (var i = 0; i < mono.Length; i++)
+        {
+            var sum = 0f;
+            for (var c = 0; c < channels; c++)
+                sum += interleaved[i * channels + c];
+            mono[i] = sum / channels;
+        }
+        return mono;
+    }
+
+    // Linear-interpolation resampler (adequate for tagging; use a band-limited resampler for best fidelity).
+    public static float[] Resample(float[] src, int srcRate, int dstRate)
+    {
+        if (srcRate == dstRate || src.Length == 0)
+            return src;
+        var n = (int)((long)src.Length * dstRate / srcRate);
+        var dst = new float[n];
+        var step = (double)srcRate / dstRate;
+        for (var i = 0; i < n; i++)
+        {
+            var p = i * step;
+            var j = (int)p;
+            var t = (float)(p - j);
+            dst[i] = j + 1 < src.Length ? src[j] + (src[j + 1] - src[j]) * t : src[src.Length - 1];
+        }
+        return dst;
+    }
+
+    void Schedule(float[] samples, int sampleRate)
+    {
+        if (m_Worker == null)
+            throw new InvalidOperationException("CedTiny.Load must be called before Classify.");
+        var x = sampleRate == SampleRate ? samples : Resample(samples, sampleRate, SampleRate);
+        var n = Math.Min(x.Length, WindowSamples);
+        Array.Clear(m_Window, 0, WindowSamples - n);
+        Array.Copy(x, x.Length - n, m_Window, WindowSamples - n, n);
+        m_InputTensor.Upload(m_Window);
+        m_Worker.Schedule(m_InputTensor);
+    }
+
+    float[] Read()
+    {
+        using var scores = (m_Worker.PeekOutput("scores") as Tensor<float>).ReadbackAndClone();
+        using var embedding = (m_Worker.PeekOutput("embedding") as Tensor<float>).ReadbackAndClone();
+        embedding.DownloadToArray().CopyTo(Embedding, 0);
+        return scores.DownloadToArray();
+    }
+
+    void DisposeResources()
+    {
+        m_Worker?.Dispose();
+        m_Worker = null;
+        m_InputTensor?.Dispose();
+        m_InputTensor = null;
+    }
+
+    public void Dispose()
+    {
+        DisposeResources();
+    }
+}
+}

Runtime/CedTiny.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bf91064d8c734bbfabd217c3600407b1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Sky.Sentis.CedTiny.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Sky.Sentis.CedTiny",
+    "rootNamespace": "SentisModels",
+    "references": [
+        "Unity.InferenceEngine"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Runtime/Sky.Sentis.CedTiny.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 20a66193364c438abaeb54413f39873f
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package.json

@@ -0,0 +1,9 @@
+{
+  "name": "com.sky.sentis.ced-tiny",
+  "version": "0.1.0",
+  "displayName": "CED-Tiny Audio Tagger (Sentis)",
+  "unity": "6000.0",
+  "dependencies": {
+    "com.unity.ai.inference": "2.6.1"
+  }
+}

package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ab637ba17ae0498882302f4dfa1535e5
+PackageManifestImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: