Update app.py

app.py

@@ -15,6 +15,38 @@ import spaces
 model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
 processor = MusicgenProcessor.from_pretrained("facebook/musicgen-small")
 
+title = "MusicGen Streaming"
+
+description = """
+Stream the outputs of the MusicGen text-to-music model by playing the generated audio as soon as the first chunk is ready. 
+Demo uses [MusicGen Small](https://huggingface.co/facebook/musicgen-small) in the 🤗 Transformers library.
+"""
+
+article = """
+## How Does It Work?
+
+MusicGen is an auto-regressive transformer-based model, meaning generates audio codes (tokens) in a causal fashion.
+At each decoding step, the model generates a new set of audio codes, conditional on the text input and all previous audio codes. From the 
+frame rate of the [EnCodec model](https://huggingface.co/facebook/encodec_32khz) used to decode the generated codes to audio waveform, 
+each set of generated audio codes corresponds to 0.02 seconds. This means we require a total of 1000 decoding steps to generate
+20 seconds of audio.
+
+Rather than waiting for the entire audio sequence to be generated, which would require the full 1000 decoding steps, we can start 
+playing the audio after a specified number of decoding steps have been reached, a techinque known as [*streaming*](https://huggingface.co/docs/transformers/main/en/generation_strategies#streaming). 
+For example, after 250 steps we have the first 5 seconds of audio ready, and so can play this without waiting for the remaining 
+750 decoding steps to be complete. As we continue to generate with the MusicGen model, we append new chunks of generated audio 
+to our output waveform on-the-fly. After the full 1000 decoding steps, the generated audio is complete, and is composed of four 
+chunks of audio, each corresponding to 250 tokens.
+
+This method of playing incremental generations reduces the latency of the MusicGen model from the total time to generate 1000 tokens, 
+to the time taken to play the first chunk of audio (250 tokens). This can result in significant improvements to perceived latency, 
+particularly when the chunk size is chosen to be small. In practice, the chunk size should be tuned to your device: using a 
+smaller chunk size will mean that the first chunk is ready faster, but should not be chosen so small that the model generates slower 
+than the time it takes to play the audio.
+
+For details on how the streaming class works, check out the source code for the [MusicgenStreamer](https://huggingface.co/spaces/sanchit-gandhi/musicgen-streaming/blob/main/app.py#L51).
+"""
+
 
 class MusicgenStreamer(BaseStreamer):
     def __init__(
@@ -181,12 +213,24 @@ demo = gr.Interface(
     fn=generate_audio,
     inputs=[
         gr.Text(label="Prompt", value="80s pop track with synth and instrumentals"),
-        gr.Slider(10, 30, value=15, step=5, label="Audio length in s"),
-        gr.Slider(2, 10, value=2, step=2, label="Streaming interval in s"),
+        gr.Slider(10, 30, value=15, step=5, label="Audio length in seconds"),
+        gr.Slider(0.5, 2.5, value=0.5, step=0.5, label="Streaming interval in seconds", info="Lower = shorter chunks, lower latency, more codec steps"),
+        gr.Slider(0, 10, value=5, step=1, label="Seed for random generations"),
     ],
     outputs=[
         gr.Audio(label="Generated Music", streaming=True, autoplay=True)
     ],
+    examples=[
+        ["An 80s driving pop song with heavy drums and synth pads in the background", 20, 0.5, 5],
+        ["A cheerful country song with acoustic guitars", 15, 0.5, 5],
+        ["90s rock song with electric guitar and heavy drums", 15, 0.5, 5],
+        ["a light and cheerly EDM track, with syncopated drums, aery pads, and strong emotions bpm: 130", 30, 0.5, 5],
+        ["lofi slow bpm electro chill with organic samples", 30, 0.5, 5],
+    ],
+    title=title,
+    description=description,
+    article=article,
 )
 
+
 demo.queue().launch()