Update app.py

app.py

@@ -9,11 +9,413 @@ from transformers import MusicgenMelodyForConditionalGeneration, AutoProcessor,
 from transformers.generation.streamers import BaseStreamer
 
 import gradio as gr
-import spaces
+import io, wave
 
+# import spaces
 
-model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")
-processor = AutoProcessor.from_pretrained("facebook/musicgen-melody")
+
+from transformers import MusicgenMelodyForConditionalGeneration, MusicgenForConditionalGeneration, AutoProcessor, set_seed
+from transformers.modeling_outputs import BaseModelOutput
+from transformers.utils import logging
+from transformers.generation.configuration_utils import GenerationConfig
+from transformers.generation.logits_process import ClassifierFreeGuidanceLogitsProcessor, LogitsProcessorList
+from transformers.generation.stopping_criteria import StoppingCriteriaList
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
+
+import copy
+import torch
+import inspect
+
+from demucs import pretrained
+from demucs.apply import apply_model
+from demucs.audio import convert_audio
+
+logger = logging.get_logger(__name__)
+
+
+class MusicgenMelodyForLongFormConditionalGeneration(MusicgenMelodyForConditionalGeneration):
+    stride_longform = 500
+    max_longform_generation_length = 4000
+
+
+    def _prepare_audio_encoder_kwargs_for_longform_generation(
+        self, audio_codes, model_kwargs,):
+        frames, bsz, codebooks, seq_len = audio_codes.shape
+
+        if frames != 1:
+            raise ValueError(
+                f"Expected 1 frame in the audio code outputs, got {frames} frames. Ensure chunking is "
+                "disabled by setting `chunk_length=None` in the audio encoder."
+            )
+
+        decoder_input_ids = audio_codes[0, ...].reshape(bsz * self.decoder.num_codebooks, seq_len)
+
+        model_kwargs["decoder_input_ids"] = decoder_input_ids
+        return model_kwargs
+    
+    @torch.no_grad()
+    def generate(
+        self,
+        inputs: Optional[torch.Tensor] = None,
+        generation_config: Optional[GenerationConfig] = None,
+        logits_processor: Optional[LogitsProcessorList] = None,
+        stopping_criteria: Optional[StoppingCriteriaList] = None,
+        synced_gpus: Optional[bool] = None,
+        streamer: Optional["BaseStreamer"] = None,
+        **kwargs,
+    ):
+        """
+
+        Generates sequences of token ids for models with a language modeling head.
+
+        <Tip warning={true}>
+
+        Most generation-controlling parameters are set in `generation_config` which, if not passed, will be set to the
+        model's default generation configuration. You can override any `generation_config` by passing the corresponding
+        parameters to generate(), e.g. `.generate(inputs, num_beams=4, do_sample=True)`.
+
+        For an overview of generation strategies and code examples, check out the [following
+        guide](./generation_strategies).
+
+        </Tip>
+
+        Parameters:
+            inputs (`torch.Tensor` of varying shape depending on the modality, *optional*):
+                The sequence used as a prompt for the generation or as model inputs to the encoder. If `None` the
+                method initializes it with `bos_token_id` and a batch size of 1. For decoder-only models `inputs`
+                should be in the format `input_ids`. For encoder-decoder models *inputs* can represent any of
+                `input_ids`, `input_values`, `input_features`, or `pixel_values`.
+            generation_config (`~generation.GenerationConfig`, *optional*):
+                The generation configuration to be used as base parametrization for the generation call. `**kwargs`
+                passed to generate matching the attributes of `generation_config` will override them. If
+                `generation_config` is not provided, the default will be used, which had the following loading
+                priority: 1) from the `generation_config.json` model file, if it exists; 2) from the model
+                configuration. Please note that unspecified parameters will inherit [`~generation.GenerationConfig`]'s
+                default values, whose documentation should be checked to parameterize generation.
+            logits_processor (`LogitsProcessorList`, *optional*):
+                Custom logits processors that complement the default logits processors built from arguments and
+                generation config. If a logit processor is passed that is already created with the arguments or a
+                generation config an error is thrown. This feature is intended for advanced users.
+            stopping_criteria (`StoppingCriteriaList`, *optional*):
+                Custom stopping criteria that complement the default stopping criteria built from arguments and a
+                generation config. If a stopping criteria is passed that is already created with the arguments or a
+                generation config an error is thrown. This feature is intended for advanced users.
+            synced_gpus (`bool`, *optional*, defaults to `False`):
+                Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
+            streamer (`BaseStreamer`, *optional*):
+                Streamer object that will be used to stream the generated sequences. Generated tokens are passed
+                through `streamer.put(token_ids)` and the streamer is responsible for any further processing.
+            kwargs (`Dict[str, Any]`, *optional*):
+                Ad hoc parametrization of `generate_config` and/or additional model-specific kwargs that will be
+                forwarded to the `forward` function of the model. If the model is an encoder-decoder model, encoder
+                specific kwargs should not be prefixed and decoder specific kwargs should be prefixed with *decoder_*.
+
+        Return:
+            [`~utils.ModelOutput`] or `torch.LongTensor`: A [`~utils.ModelOutput`] (if `return_dict_in_generate=True`
+            or when `config.return_dict_in_generate=True`) or a `torch.FloatTensor`.
+
+                If the model is *not* an encoder-decoder model (`model.config.is_encoder_decoder=False`), the possible
+                [`~utils.ModelOutput`] types are:
+
+                    - [`~generation.GenerateDecoderOnlyOutput`],
+                    - [`~generation.GenerateBeamDecoderOnlyOutput`]
+
+                If the model is an encoder-decoder model (`model.config.is_encoder_decoder=True`), the possible
+                [`~utils.ModelOutput`] types are:
+
+                    - [`~generation.GenerateEncoderDecoderOutput`],
+                    - [`~generation.GenerateBeamEncoderDecoderOutput`]
+        """
+        # 1. Handle `generation_config` and kwargs that might update it, and validate the resulting objects
+        if generation_config is None:
+            generation_config = self.generation_config
+
+        generation_config = copy.deepcopy(generation_config)
+        model_kwargs = generation_config.update(**kwargs)  # All unused kwargs must be model kwargs
+        generation_config.validate()
+        self._validate_model_kwargs(model_kwargs.copy())
+
+        # 2. Set generation parameters if not already defined
+        logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
+        stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
+
+        if generation_config.pad_token_id is None and generation_config.eos_token_id is not None:
+            if model_kwargs.get("attention_mask", None) is None:
+                logger.warning(
+                    "The attention mask and the pad token id were not set. As a consequence, you may observe "
+                    "unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results."
+                )
+            eos_token_id = generation_config.eos_token_id
+            if isinstance(eos_token_id, list):
+                eos_token_id = eos_token_id[0]
+            logger.warning(f"Setting `pad_token_id` to `eos_token_id`:{eos_token_id} for open-end generation.")
+            generation_config.pad_token_id = eos_token_id
+
+        # 3. Define model inputs
+        # inputs_tensor has to be defined
+        # model_input_name is defined if model-specific keyword input is passed
+        # otherwise model_input_name is None
+        # all model-specific keyword inputs are removed from `model_kwargs`
+        inputs_tensor, model_input_name, model_kwargs = self._prepare_model_inputs(
+            inputs, generation_config.bos_token_id, model_kwargs
+        )
+        batch_size = inputs_tensor.shape[0]
+
+        # 4. Define other model kwargs
+        model_kwargs["output_attentions"] = generation_config.output_attentions
+        model_kwargs["output_hidden_states"] = generation_config.output_hidden_states
+        model_kwargs["use_cache"] = generation_config.use_cache
+        model_kwargs["guidance_scale"] = generation_config.guidance_scale
+
+        if model_kwargs.get("attention_mask", None) is None:
+            model_kwargs["attention_mask"] = self._prepare_attention_mask_for_generation(
+                inputs_tensor, generation_config.pad_token_id, generation_config.eos_token_id
+            )
+
+        if "encoder_hidden_states" not in model_kwargs:
+            # encoder_hidden_states are created and added to `model_kwargs`
+            model_kwargs = self._prepare_encoder_hidden_states_kwargs_for_generation(
+                inputs_tensor,
+                model_kwargs,
+                model_input_name,
+                guidance_scale=generation_config.guidance_scale,
+            )
+
+        # 5. Prepare `input_ids` which will be used for auto-regressive generation
+        input_ids, model_kwargs = self._prepare_decoder_input_ids_for_generation(
+            batch_size=batch_size,
+            model_input_name=model_input_name,
+            model_kwargs=model_kwargs,
+            decoder_start_token_id=generation_config.decoder_start_token_id,
+            bos_token_id=generation_config.bos_token_id,
+            device=inputs_tensor.device,
+        )
+
+        # 6. Prepare `max_length` depending on other stopping criteria.
+        input_ids_seq_length = input_ids.shape[-1]
+
+        has_default_max_length = kwargs.get("max_length") is None and generation_config.max_length is not None
+        if has_default_max_length and generation_config.max_new_tokens is None:
+            logger.warning(
+                f"Using the model-agnostic default `max_length` (={generation_config.max_length}) "
+                "to control the generation length. We recommend setting `max_new_tokens` to control the maximum length of the generation."
+            )
+        elif generation_config.max_new_tokens is not None:
+            if not has_default_max_length:
+                logger.warning(
+                    f"Both `max_new_tokens` (={generation_config.max_new_tokens}) and `max_length`(="
+                    f"{generation_config.max_length}) seem to have been set. `max_new_tokens` will take precedence. "
+                    "Please refer to the documentation for more information. "
+                    "(https://huggingface.co/docs/transformers/main/en/main_classes/text_generation)"
+                )
+            generation_config.max_length = generation_config.max_new_tokens + input_ids_seq_length
+
+        if generation_config.min_length is not None and generation_config.min_length > generation_config.max_length:
+            raise ValueError(
+                f"Unfeasible length constraints: the minimum length ({generation_config.min_length}) is larger than"
+                f" the maximum length ({generation_config.max_length})"
+            )
+        if input_ids_seq_length >= generation_config.max_length:
+            logger.warning(
+                f"Input length of decoder_input_ids is {input_ids_seq_length}, but `max_length` is set to"
+                f" {generation_config.max_length}. This can lead to unexpected behavior. You should consider"
+                " increasing `max_new_tokens`."
+            )
+
+        # build the delay pattern mask for offsetting each codebook prediction by 1 (this behaviour is specific to Musicgen Melody)
+        input_ids, decoder_delay_pattern_mask = self.decoder.build_delay_pattern_mask(
+            input_ids,
+            pad_token_id=generation_config.decoder_start_token_id,
+            max_length=generation_config.max_length,
+        )
+        # stash the delay mask so that we don't have to recompute in each forward pass
+        model_kwargs["decoder_delay_pattern_mask"] = decoder_delay_pattern_mask
+
+        # input_ids are ready to be placed on the streamer (if used)
+        if streamer is not None:
+            streamer.put(input_ids.cpu())
+
+        # 7. determine generation mode
+        is_greedy_gen_mode = (
+            (generation_config.num_beams == 1)
+            and (generation_config.num_beam_groups == 1)
+            and generation_config.do_sample is False
+        )
+        is_sample_gen_mode = (
+            (generation_config.num_beams == 1)
+            and (generation_config.num_beam_groups == 1)
+            and generation_config.do_sample is True
+        )
+
+        # 8. prepare batched CFG externally (to enable coexistance with the unbatched CFG)
+        if generation_config.guidance_scale is not None and generation_config.guidance_scale > 1:
+            logits_processor.append(ClassifierFreeGuidanceLogitsProcessor(generation_config.guidance_scale))
+            generation_config.guidance_scale = None
+
+        # 9. prepare distribution pre_processing samplers
+        logits_processor = self._get_logits_processor(
+            generation_config=generation_config,
+            input_ids_seq_length=input_ids_seq_length,
+            encoder_input_ids=inputs_tensor,
+            prefix_allowed_tokens_fn=None,
+            logits_processor=logits_processor,
+        )
+
+        # 10. prepare stopping criteria
+        stopping_criteria = self._get_stopping_criteria(
+            generation_config=generation_config, stopping_criteria=stopping_criteria
+        )
+
+        # ENTER LONGFORM GENERATION LOOP
+        generated_tokens = []
+        
+        # the first timestamps corresponds to decoder_start_token
+        current_generated_length = input_ids.shape[1] - 1
+        
+        while current_generated_length <= self.max_longform_generation_length:
+            if is_greedy_gen_mode:
+                if generation_config.num_return_sequences > 1:
+                    raise ValueError(
+                        "num_return_sequences has to be 1 when doing greedy search, "
+                        f"but is {generation_config.num_return_sequences}."
+                    )
+
+                # 11. run greedy search
+                outputs = self._greedy_search(
+                    input_ids,
+                    logits_processor=logits_processor,
+                    stopping_criteria=stopping_criteria,
+                    pad_token_id=generation_config.pad_token_id,
+                    eos_token_id=generation_config.eos_token_id,
+                    output_scores=generation_config.output_scores,
+                    return_dict_in_generate=generation_config.return_dict_in_generate,
+                    synced_gpus=synced_gpus,
+                    streamer=streamer,
+                    **model_kwargs,
+                )
+
+            elif is_sample_gen_mode:
+                # 11. prepare logits warper
+                logits_warper = self._get_logits_warper(generation_config)
+
+                # expand input_ids with `num_return_sequences` additional sequences per batch
+                input_ids, model_kwargs = self._expand_inputs_for_generation(
+                    input_ids=input_ids,
+                    expand_size=generation_config.num_return_sequences,
+                    is_encoder_decoder=self.config.is_encoder_decoder,
+                    **model_kwargs,
+                )
+
+                # 12. run sample
+                outputs = self._sample(
+                    input_ids,
+                    logits_processor=logits_processor,
+                    logits_warper=logits_warper,
+                    stopping_criteria=stopping_criteria,
+                    pad_token_id=generation_config.pad_token_id,
+                    eos_token_id=generation_config.eos_token_id,
+                    output_scores=generation_config.output_scores,
+                    return_dict_in_generate=generation_config.return_dict_in_generate,
+                    synced_gpus=synced_gpus,
+                    streamer=streamer,
+                    **model_kwargs,
+                )
+
+            else:
+                raise ValueError(
+                    "Got incompatible mode for generation, should be one of greedy or sampling. "
+                    "Ensure that beam search is de-activated by setting `num_beams=1` and `num_beam_groups=1`."
+                )
+
+            if generation_config.return_dict_in_generate:
+                output_ids = outputs.sequences
+            else:
+                output_ids = outputs
+
+            # apply the pattern mask to the final ids
+            output_ids = self.decoder.apply_delay_pattern_mask(output_ids, model_kwargs["decoder_delay_pattern_mask"])
+
+            # revert the pattern delay mask by filtering the pad token id
+            output_ids = output_ids[output_ids != generation_config.pad_token_id].reshape(
+                batch_size, self.decoder.num_codebooks, -1
+            )
+            if len(generated_tokens) >= 1:
+                generated_tokens.append(output_ids[:, :, self.stride_longform:])
+            else:
+                generated_tokens.append(output_ids)
+            
+            current_generated_length += generated_tokens[-1].shape[-1]
+            
+            # append the frame dimension back to the audio codes
+            # use last generated tokens as begining of the newest generation
+            output_ids = output_ids[None, :, :, (output_ids.shape[-1] - self.stride_longform):]
+            
+            model_kwargs = self._prepare_audio_encoder_kwargs_for_longform_generation(output_ids, model_kwargs)
+
+            # Prepare new `input_ids` which will be used for auto-regressive generation
+            input_ids, model_kwargs = self._prepare_decoder_input_ids_for_generation(
+                batch_size=batch_size,
+                model_input_name="input_ids",
+                model_kwargs=model_kwargs,
+                decoder_start_token_id=self.generation_config.decoder_start_token_id,
+                bos_token_id=self.generation_config.bos_token_id,
+                device=input_ids.device,
+            )
+            # build the delay pattern mask for offsetting each codebook prediction by 1 (this behaviour is specific to Musicgen Melody)
+            input_ids, decoder_delay_pattern_mask = self.decoder.build_delay_pattern_mask(
+                input_ids,
+                pad_token_id=generation_config.decoder_start_token_id,
+                max_length=generation_config.max_length,
+            )
+            # stash the delay mask so that we don't have to recompute in each forward pass
+            model_kwargs["decoder_delay_pattern_mask"] = decoder_delay_pattern_mask
+            
+            
+            # TODO(YL): periodic prompt song
+
+            # encoder_hidden_states are created and added to `model_kwargs`
+            # model_kwargs = self._prepare_encoder_hidden_states_kwargs_for_generation(
+            #     inputs_tensor,
+            #     model_kwargs,
+            #     model_input_name,
+            #     guidance_scale=generation_config.guidance_scale,
+            # )
+            
+        # append the frame dimension back to the audio codes
+        output_ids = torch.cat(generated_tokens, dim=-1)[None, ...]
+        
+        # Specific to this gradio demo
+        if streamer is not None:
+            streamer.end(True)
+            
+        audio_scales = model_kwargs.get("audio_scales")
+        if audio_scales is None:
+            audio_scales = [None] * batch_size
+
+        if self.decoder.config.audio_channels == 1:
+            output_values = self.audio_encoder.decode(
+                output_ids,
+                audio_scales=audio_scales,
+            ).audio_values
+        else:
+            codec_outputs_left = self.audio_encoder.decode(output_ids[:, :, ::2, :], audio_scales=audio_scales)
+            output_values_left = codec_outputs_left.audio_values
+
+            codec_outputs_right = self.audio_encoder.decode(output_ids[:, :, 1::2, :], audio_scales=audio_scales)
+            output_values_right = codec_outputs_right.audio_values
+
+            output_values = torch.cat([output_values_left, output_values_right], dim=1)
+
+        if generation_config.return_dict_in_generate:
+            outputs.sequences = output_values
+            return outputs
+        else:
+            return output_values
+
+model = MusicgenMelodyForLongFormConditionalGeneration.from_pretrained("facebook/musicgen-melody", revision="refs/pr/14")#, attn_implementation="sdpa")
+processor = AutoProcessor.from_pretrained("facebook/musicgen-melody", revision="refs/pr/14")
+
+demucs = pretrained.get_model('htdemucs')
 
 title = "MusicGen Streaming"
 
@@ -52,11 +454,12 @@ For details on how the streaming class works, check out the source code for the
 class MusicgenStreamer(BaseStreamer):
     def __init__(
         self,
-        model: MusicgenForConditionalGeneration,
+        model: MusicgenMelodyForConditionalGeneration,
         device: Optional[str] = None,
         play_steps: Optional[int] = 10,
         stride: Optional[int] = None,
         timeout: Optional[float] = None,
+        is_longform: Optional[bool] = False,
     ):
         """
         Streamer that stores playback-ready audio in a queue, to be used by a downstream application as an iterator. This is
@@ -79,6 +482,8 @@ class MusicgenStreamer(BaseStreamer):
             timeout (`int`, *optional*):
                 The timeout for the audio queue. If `None`, the queue will block indefinitely. Useful to handle exceptions
                 in `.generate()`, when it is called in a separate thread.
+            is_longform (`bool`, *optional*, defaults to `False`):
+                If `is_longform`, will takes into account long form stride and non regular ending signal.
         """
         self.decoder = model.decoder
         self.audio_encoder = model.audio_encoder
@@ -94,7 +499,12 @@ class MusicgenStreamer(BaseStreamer):
             self.stride = hop_length * (play_steps - self.decoder.num_codebooks) // 6
         self.token_cache = None
         self.to_yield = 0
-
+        
+        self.is_longform = is_longform
+        if is_longform:
+            self.longform_stride = model.stride_longform
+            self.longform_stride_applied = True
+        
         # varibles used in the thread process
         self.audio_queue = Queue()
         self.stop_signal = None
@@ -140,17 +550,24 @@ class MusicgenStreamer(BaseStreamer):
 
         if self.token_cache.shape[-1] % self.play_steps == 0:
             audio_values = self.apply_delay_pattern_mask(self.token_cache)
+            if self.is_longform:
+                if not self.longform_stride_applied:
+                    self.to_yield = self.to_yield + self.longform_stride
+                    self.longform_stride_applied = True
             self.on_finalized_audio(audio_values[self.to_yield : -self.stride])
             self.to_yield += len(audio_values) - self.to_yield - self.stride
 
-    def end(self):
+    def end(self, stream_end=False):
         """Flushes any remaining cache and appends the stop symbol."""
         if self.token_cache is not None:
             audio_values = self.apply_delay_pattern_mask(self.token_cache)
         else:
             audio_values = np.zeros(self.to_yield)
 
-        self.on_finalized_audio(audio_values[self.to_yield :], stream_end=True)
+        stream_end = (not self.is_longform) or stream_end
+        if self.is_longform:
+            self.longform_stride_applied = False
+        self.on_finalized_audio(audio_values[self.to_yield :], stream_end=stream_end)
 
     def on_finalized_audio(self, audio: np.ndarray, stream_end: bool = False):
         """Put the new audio in the queue. If the stream is ending, also put a stop signal in the queue."""
@@ -175,11 +592,29 @@ frame_rate = model.audio_encoder.config.frame_rate
 target_dtype = np.int16
 max_range = np.iinfo(target_dtype).max
 
-
-@spaces.GPU()
-def generate_audio(text_prompt, audio_length_in_s=10.0, play_steps_in_s=2.0, seed=0):
+def wave_header_chunk(frame_input=b"", channels=1, sample_width=2, sample_rate=24000):
+    # This will create a wave header then append the frame input
+    # It should be first on a streaming wav file
+    # Other frames better should not have it (else you will hear some artifacts each chunk start)
+    wav_buf = io.BytesIO()
+    with wave.open(wav_buf, "wb") as vfout:
+        vfout.setnchannels(channels)
+        vfout.setsampwidth(sample_width)
+        vfout.setframerate(sample_rate)
+        vfout.writeframes(frame_input)
+
+    wav_buf.seek(0)
+    
+    return wav_buf.read()
+
+# @spaces.GPU()
+def generate_audio(text_prompt, audio, audio_length_in_s=10.0, play_steps_in_s=2.0, seed=0):
     max_new_tokens = int(frame_rate * audio_length_in_s)
     play_steps = int(frame_rate * play_steps_in_s)
+    
+    if audio is not None:
+        audio = convert_audio(torch.tensor(audio[1]).float(), audio[0], demucs.samplerate, demucs.audio_channels)
+        audio = apply_model(demucs, audio[None])
 
     device = "cuda:0" if torch.cuda.is_available() else "cpu"
     if device != model.device:
@@ -187,52 +622,70 @@ def generate_audio(text_prompt, audio_length_in_s=10.0, play_steps_in_s=2.0, see
         if device == "cuda:0":
             model.half()
 
-    inputs = processor(
-        text=text_prompt,
-        padding=True,
-        return_tensors="pt",
-    )
+    if audio is not None:
+        inputs = processor(
+            text=text_prompt,
+            padding=True,
+            return_tensors="pt",
+            audio=audio, sampling_rate=demucs.samplerate
+        )
+        if device == "cuda:0":
+            inputs["input_features"] = inputs["input_features"].to(torch.float16)
+    else:
+        inputs = processor(
+            text=text_prompt,
+            padding=True,
+            return_tensors="pt",
+        )
 
-    streamer = MusicgenStreamer(model, device=device, play_steps=play_steps)
+    streamer = MusicgenStreamer(model, device=device, play_steps=play_steps, is_longform=True)
 
     generation_kwargs = dict(
         **inputs.to(device),
+        temperature=1.2,
         streamer=streamer,
         max_new_tokens=max_new_tokens,
     )
     thread = Thread(target=model.generate, kwargs=generation_kwargs)
     thread.start()
+    
+    yield wave_header_chunk() 
 
     set_seed(seed)
     for new_audio in streamer:
         print(f"Sample of length: {round(new_audio.shape[0] / sampling_rate, 2)} seconds")
+        
         new_audio = (new_audio * max_range).astype(np.int16)
-        yield sampling_rate, new_audio
+        # (sampling_rate, new_audio)
+        yield new_audio.tobytes()
+
 
 
 demo = gr.Interface(
     fn=generate_audio,
     inputs=[
         gr.Text(label="Prompt", value="80s pop track with synth and instrumentals"),
+        gr.Audio(source="upload", type="numpy", label="Conditioning audio"),
         gr.Slider(10, 30, value=15, step=5, label="Audio length in seconds"),
         gr.Slider(0.5, 2.5, value=1.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)
+        gr.Audio(label="Generated Music", autoplay=True,  interactive=False, streaming=True)
     ],
     examples=[
-        ["An 80s driving pop song with heavy drums and synth pads in the background", 30, 1.5, 5],
-        ["A cheerful country song with acoustic guitars", 30, 1.5, 5],
-        ["90s rock song with electric guitar and heavy drums", 30, 1.5, 5],
-        ["a light and cheerly EDM track, with syncopated drums, aery pads, and strong emotions bpm: 130", 30, 1.5, 5],
-        ["lofi slow bpm electro chill with organic samples", 30, 1.5, 5],
+        ["An 80s driving pop song with heavy drums and synth pads in the background", None, 30, 1.5, 5],
+        ["A cheerful country song with acoustic guitars", None, 30, 1.5, 5],
+        ["90s rock song with electric guitar and heavy drums", None, 30, 1.5, 5],
+        ["a light and cheerly EDM track, with syncopated drums, aery pads, and strong emotions bpm: 130", None, 30, 1.5, 5],
+        ["lofi slow bpm electro chill with organic samples", None, 30, 1.5, 5],
     ],
     title=title,
     description=description,
+    allow_flagging=False,
     article=article,
     cache_examples=False,
 )
 
 
-demo.queue().launch()
+demo.queue().launch(debug=True)