Upload 71 files

.gitattributes

@@ -34,3 +34,12 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 tokenizer.json filter=lfs diff=lfs merge=lfs -text
+cpp/gemma_v1/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+cpp/sample_data_old/pickup_breezy-common_voice_zh-TW_17376838-breezyvoice-00818.pcm filter=lfs diff=lfs merge=lfs -text
+cpp/sample_data_old/pickup_breezy-common_voice_zh-TW_17376838-breezyvoice-00818.wav filter=lfs diff=lfs merge=lfs -text
+cpp/sample_data_old/pickup_breezy-common_voice_zh-TW_17382475-breezyvoice-01452.wav filter=lfs diff=lfs merge=lfs -text
+cpp/sample_data_old/pickup_breezy-common_voice_zh-TW_17382570-breezyvoice-01041.pcm filter=lfs diff=lfs merge=lfs -text
+cpp/sample_data_old/pickup_breezy-common_voice_zh-TW_17382570-breezyvoice-01041.wav filter=lfs diff=lfs merge=lfs -text
+cpp/sample_data_old/pickup_breezy-common_voice_zh-TW_17382594-breezyvoice-00389.pcm filter=lfs diff=lfs merge=lfs -text
+cpp/sample_data_old/pickup_breezy-common_voice_zh-TW_17382594-breezyvoice-00389.wav filter=lfs diff=lfs merge=lfs -text
+cpp/sample_data/pickup_breezy-common_voice_zh-TW_17382570-breezyvoice-01041.wav filter=lfs diff=lfs merge=lfs -text

cpp/ASRDataset.py

@@ -0,0 +1,794 @@
+import datasets
+datasets.config.DOWNLOADED_DATASETS_PATH = "/mnt/jeff/huggingface/data"
+import os
+os.environ['HF_HOME'] = '/mnt/jeff/huggingface'
+
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+import sacrebleu
+
+from datasets import load_dataset
+from torch.utils.data import Dataset, ConcatDataset
+from tqdm import tqdm
+from transformers import (
+    BatchFeature,
+)
+import pandas as pd
+import soundfile as sf
+from datasets import Audio
+import random
+from copy import deepcopy
+import torchaudio
+
+ANSWER_SUFFIX = "<end_of_turn>"
+_IGNORE_INDEX = -100
+class BaseAudioDataset(Dataset):
+    def __init__(self, processor, split, sampling_rate=16000, debug=False):
+        self.processor = processor
+        self.training = "train" in split or 'other' in split
+        self.debug = debug
+        self.sampling_rate = sampling_rate
+        self.name = ""
+        
+    def set_dataset_name(self, name):
+        self.name = name
+
+    @staticmethod
+    def filter_corrupted_files(data, audio_field, text_fields, dataset_name, sampling_rate=16000, debug=True):
+        original_size = len(data)
+        
+        data = data.cast_column(audio_field, Audio(decode=False))
+        
+        def identify_corrupted_files(example):
+            try:
+                sf.read(example[audio_field]["path"])
+                
+                for field in text_fields:
+                    if field in example and example[field].replace('"', '') == "":
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        data = data.filter(identify_corrupted_files, num_proc=16)
+        validated_size = len(data)
+        
+        # Audio Decoding
+        data = data.cast_column(audio_field, Audio(sampling_rate=sampling_rate, decode=True))
+        
+        if debug:
+            print(f"Dataset: {dataset_name}")
+            print(f"Original data nums: {original_size}")
+            print(f"After filtering data nums: {validated_size}")
+            print(f"Filtering ratio: {validated_size/original_size:.2%}")
+            
+        return data
+
+    @staticmethod
+    def filter_by_audio_length(data, audio_field, min_sec=2, max_sec=20, debug=True):
+        original_size = len(data)
+        
+        def filter_audio_by_length(example):
+            try:
+                audio = example[audio_field]['array']
+                channel = 1
+                if hasattr(audio, 'ndim') and audio.ndim > 1:
+                    channel = audio.ndim
+                    audio = audio.squeeze()
+                audio_length = len(audio) / example[audio_field]['sampling_rate'] / channel
+                return min_sec <= audio_length <= max_sec
+            except Exception as e:
+                if debug:
+                    print(f"Error : {str(e)[:100]}... - sample excluded")
+                return False
+        
+        data = data.filter(filter_audio_by_length, num_proc=16)
+        filtered_size = len(data)
+        
+        if debug:
+            print(f"Before Length Filtering data nums: {original_size}")
+            print(f"After Length Filtering data nums: {filtered_size}")
+            print(f"Filtering ratio: {filtered_size/original_size:.2%}")
+            
+        return data
+
+    def prepare_model_inputs(self, audio_array, instruction, answer_text):
+        user_message = {
+            'role': 'user',
+            'content': '<start_of_audio>' + instruction,
+        }
+        prompt = self.processor.tokenizer.apply_chat_template(
+            [user_message], tokenize=False, add_generation_prompt=True, add_bos=True
+        )
+        
+        inputs = self.processor(
+            text=prompt, 
+            audio=[audio_array], 
+            add_special_tokens=False, 
+            return_tensors='pt'
+        )
+        
+        answer = f"{answer_text}{ANSWER_SUFFIX}"
+        answer_ids = self.processor.tokenizer(answer, add_special_tokens=False, return_tensors='pt').input_ids
+        
+        if self.debug:
+            self.debug = False
+            task_type = 'AST' if hasattr(self, 'ast') and self.ast else 'ASR'
+            lang_info = f" - {self.lang}" if hasattr(self, 'lang') else ""
+            print(f"{task_type}{lang_info}\nPROMPT: {prompt}\nINPUT: {self.processor.decode(inputs.input_ids[0], skip_special_tokens=False)}\nANSWER: {self.processor.decode(answer_ids[0], skip_special_tokens=False)}\n")
+            print(f"INPUT_MODE: {inputs.input_modes[0].item()}")
+        
+        if self.training:
+            input_ids = torch.cat([inputs.input_ids, answer_ids], dim=1)
+            labels = torch.full_like(input_ids, _IGNORE_INDEX)
+            labels[:, -answer_ids.shape[1]:] = answer_ids
+            padding = torch.zeros((inputs.token_type_ids.shape[0], answer_ids.shape[1]))
+            token_type_ids = torch.cat([inputs.token_type_ids, padding], dim=1)
+        else:
+            input_ids = inputs.input_ids
+            labels = answer_ids
+            token_type_ids = inputs.token_type_ids
+        
+        return {
+            'input_ids': input_ids,
+            'labels': labels,
+            'token_type_ids': token_type_ids,
+            'input_audio_embeds': inputs.input_audio_embeds,
+            'audio_embed_sizes': inputs.audio_embed_sizes,
+            'input_modes': inputs.input_modes,
+        }
+        
+# Libri Speech Dataset Class
+class LibriSpeechDataset(BaseAudioDataset):
+    def __init__(self, processor, subset, split, sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name(f"LibriSpeech_{subset}")
+        # only ASR
+        self.ast = False
+        self.lang = "en"
+        
+        # load dataset
+        self.data = load_dataset("/mnt/jeff/InCar/data/librispeech_asr",
+                            subset,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+            
+        # Instruction Setting
+        self.instruction = random.choice(INSTRUCTION["asr"])
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        # Libri Speech is only for ASR
+        answer_text = data["text"].replace('"', '')
+        
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            self.instruction,
+            answer_text
+        )
+    
+# common_voice_16_1 dataset
+class CommonVoiceDataset(BaseAudioDataset):
+    def __init__(self, processor, split, source_lang, sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name(f"CommonVoice_{source_lang}")
+        # only ASR
+        self.ast = False
+        self.lang=source_lang
+        
+        # load dataset
+        if source_lang=="zh-TW":
+            data_path = "/mnt/jeff/InCar/data/common_voice_16_1"
+        else:
+            data_path = "/mnt/jeff/InCar/data/common_voice_17_0"
+        self.data = load_dataset(data_path,
+                            source_lang,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        def prepare_dataset(batch):
+            """Function to preprocess the dataset with the .map method"""
+            transcription = batch["sentence"]
+            
+            if transcription.startswith('"') and transcription.endswith('"'):
+                # we can remove trailing quotation marks as they do not affect the transcription
+                transcription = transcription[1:-1]
+            
+            if transcription[-1] not in [".", "?", "!"]:
+                # append a full-stop to sentences that do not end in punctuation
+                transcription = transcription + "."
+            
+            batch["sentence"] = transcription
+            
+            return batch
+
+        
+        import opencc
+        converter = opencc.OpenCC('s2tw.json')
+        def To_zhTW(batch):
+            
+            transcription = converter.convert(batch["sentence"])
+            batch["sentence"] = transcription
+            
+            return batch
+        self.data = self.data.map(prepare_dataset, desc="preprocess dataset")
+        if source_lang=='zh-CN':
+            self.data = self.data.map(To_zhTW, desc="preprocess dataset To_zhTW")
+        
+        
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+
+        if source_lang == "zh-TW" and split=='train':
+            import torchaudio
+            from torchaudio import transforms
+            import copy
+            import pickle
+            import os
+            def subsample(batch):
+                batch['audio']['array']=torchaudio.functional.resample(torch.FloatTensor(batch['audio']['array']), orig_freq=batch['audio']['sampling_rate'], new_freq=16000)
+                batch['audio']['sampling_rate']=16000
+                return batch
+            def TW_data_augment_fast(batch):
+                speed_perturb_fast = transforms.SpeedPerturbation(batch['audio']['sampling_rate'], [1.1])
+                new_array_fast = speed_perturb_fast(torch.FloatTensor(batch['audio']['array']))[0]
+                batch['audio']['array'] = new_array_fast
+                return batch
+            def TW_data_augment_slow(batch):
+                speed_perturb_slow = transforms.SpeedPerturbation(batch['audio']['sampling_rate'], [0.9])
+                new_array_slow = speed_perturb_slow(torch.FloatTensor(batch['audio']['array']))[0]
+                batch['audio']['array'] = new_array_slow
+                return batch
+            # data = self.data.map(subsample, num_proc=1, desc="subsample")
+            fast_path = '/mnt/jeff/InCar/data/tw_fast.pkl'
+            if not os.path.exists(fast_path):
+                data_fast = self.data.map(TW_data_augment_fast, num_proc=1, desc="augment fast")
+                with open(fast_path,'wb') as f:
+                    pickle.dump(data_fast,f)
+            else:
+                with open(fast_path,'rb') as f:
+                    data_fast=pickle.load(f)
+            
+            slow_path = '/mnt/jeff/InCar/data/data_slow.pkl'
+            if not os.path.exists(slow_path):
+                data_slow = self.data.map(TW_data_augment_slow, num_proc=1, desc="augment slow")
+                with open(slow_path,'wb') as f:
+                    pickle.dump(data_slow,f)
+            else:
+                with open(slow_path,'rb') as f:
+                    data_slow=pickle.load(f)
+            self.data = [d for d in self.data]+[d for d in data_fast]+[d for d in data_slow]
+            
+        # Instruction Setting
+        self.instruction = random.choice(INSTRUCTION["asr"])
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        answer_text = data["sentence"]
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            self.instruction,
+            answer_text
+        )
+    
+
+# Fleurs Dataset Class
+class FleursDataset(BaseAudioDataset):
+    def __init__(self, processor, split, source_lang, target_lang=None, 
+                 mode="asr", sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name("Fleurs")
+        # Mode Setting (ASR or AST)
+        if mode not in ["asr", "ast"]:
+            raise ValueError("mode must be 'asr' or 'ast'.")
+        
+        self.mode = mode
+        self.ast = (mode == "ast")
+        self.source_lang = source_lang
+        
+        # Language name mapping (expand if needed)
+        self.lang_names = {
+            'en_us': 'English', 'cmn_hans': 'Mandarin Chinese'
+        }
+        
+        # load dataset - source language dataset
+        self.data = load_dataset("/mnt/jeff/InCar/data/fleurs",
+                            source_lang,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        import opencc
+        converter = opencc.OpenCC('s2tw.json')
+        def prepare_dataset(batch):
+            transcription = converter.convert(batch["transcription"])
+            batch["transcription"] = transcription
+            
+            return batch
+        if (source_lang=="cmn_hans_cn"):
+            self.data = self.data.map(prepare_dataset, desc="preprocess dataset")
+
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+        self.target_lang_name = ""
+        # When AST mode, load target language dataset.
+        if self.ast:
+            if target_lang is None:
+                raise ValueError("AST mode requires target_lang.")
+                
+            self.target_lang = target_lang
+            self.lang = f"{source_lang}_{target_lang}"
+            
+            # load dataset - target language dataset (for translation)
+            target_data = load_dataset("/mnt/jeff/InCar/data/fleurs",
+                                target_lang,
+                                split=split,
+                                trust_remote_code=True,
+                                cache_dir=Path("/mnt/jeff/InCar/data")
+                                )
+            if target_lang=="cmn_hans_cn":
+                target_data=target_data.map(prepare_dataset, desc="preprocess dataset")
+            source_dict = {item['id']: item for item in self.data}
+            target_dict = {item['id']: item for item in target_data}
+            
+            # only Common ID, add translation fields
+            common_ids = set(source_dict.keys()) & set(target_dict.keys())
+            print(f"FLEURS AST Common data filtering: {len(self.data)} -> {len(common_ids)}")
+            self.data = [
+                {**source_dict[id], 'translation': target_dict[id]['transcription']}
+                for id in common_ids
+            ]
+
+            # Instruction Setting - use target language name
+            self.target_lang_name = self.lang_names.get(target_lang, target_lang.capitalize())
+            self.instruction = random.choice(INSTRUCTION["ast"])
+        else:
+            # ASR mode
+            self.lang = source_lang
+            self.instruction = random.choice(INSTRUCTION["asr"])
+
+        if self.debug:
+            print(f"FLEURS dataset loaded: {self.mode.upper()} mode")
+            print(f"source lang: {source_lang} ({self.lang_names.get(source_lang, source_lang)})")
+            if self.ast:
+                print(f"target lang: {target_lang} ({self.lang_names.get(target_lang, target_lang)})")
+            print(f"dataset size: {len(self.data)}")
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        audio_array = data["audio"]["array"]
+
+        if self.ast:
+            answer_text = data["translation"]
+        else:
+            answer_text = data["transcription"]
+        
+        return self.prepare_model_inputs(
+            audio_array,
+            self.instruction.format(self.target_lang_name),
+            answer_text
+        )
+
+class TWCostumData(BaseAudioDataset):
+    
+    def __init__(self, processor, split="train", sampling_rate=16000,csv_path="", debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        import pandas as pd
+        from datasets import Dataset, Audio 
+        
+
+        df = pd.read_csv(csv_path).fillna('')
+        
+
+        self.set_dataset_name(f"TWCostumData")
+        self.data = Dataset.from_dict(
+                                    {
+                                        "audio": [audio for audio in df['audio']],
+                                        "sentence": [text for text in df['text']]
+                                    }
+                                ).cast_column("audio", Audio(sampling_rate=16000))
+
+        # Instruction Setting
+        self.instruction = random.choice(INSTRUCTION["asr"])
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        answer_text = data["sentence"]
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            self.instruction,
+            answer_text
+        )
+def covost_collate_fn(batch):
+    input_ids_list = []
+    labels_list = []
+    token_type_ids_list = []
+    input_audio_embeds_list = []
+    audio_embed_sizes_list = []
+    audio_attention_mask_list = []
+    input_modes_list = []
+    audio_paths = []
+    for inputs in batch:
+        if 'audio_path' in inputs:
+            audio_paths.append(inputs['audio_path'])
+        input_ids_list.append(inputs['input_ids'][0])
+        labels_list.append(inputs['labels'][0])
+        token_type_ids_list.append(inputs['token_type_ids'][0])
+        if inputs['input_modes']==2:
+            input_audio_embeds_list.append(inputs['input_audio_embeds'])
+            audio_embed_sizes_list.append(inputs['audio_embed_sizes'])
+            audio_attention_mask_list.append(
+                inputs['input_audio_embeds'].new_full((inputs['input_audio_embeds'].size(1),), True, dtype=torch.bool)
+            )
+        # else:
+        #     input_audio_embeds_list.append(None)
+        #     audio_embed_sizes_list.append(None)
+        #     audio_attention_mask_list.append(None)
+        input_modes_list.append(inputs['input_modes'])
+    # try:
+    token_type_ids = pad_sequence(token_type_ids_list, padding_side='left', padding_value=0)
+    input_ids = pad_sequence(input_ids_list, padding_side='left', padding_value=0)
+    labels = pad_sequence(labels_list, padding_side='left', padding_value=0)
+    audio_attention_mask = (
+        pad_sequence(audio_attention_mask_list, padding_side='left', padding_value=False)
+        if len(audio_attention_mask_list) > 1
+        else None
+    )
+    # except Exception as e:
+    #     print(e)
+    #     print(input_ids_list)
+    #     print(labels_list)
+    #     raise
+    attention_mask = (input_ids != 0).long()
+    input_audio_embeds = cat_with_pad(input_audio_embeds_list, dim=0) if len(input_audio_embeds_list)>0 else None
+    audio_embed_sizes = torch.cat(audio_embed_sizes_list) if len(audio_embed_sizes_list)>0 else None
+    input_modes = torch.cat(input_modes_list)
+    if len(audio_paths)>0:
+        return BatchFeature(
+            {
+                "audio_path": audio_paths,
+                'input_ids': input_ids,
+                'labels': labels,
+                'token_type_ids': token_type_ids,
+                'attention_mask': attention_mask,
+                'input_audio_embeds': input_audio_embeds,
+                'audio_embed_sizes': audio_embed_sizes,
+                'audio_attention_mask': audio_attention_mask,
+                'input_modes': input_modes,
+            }
+        )
+    else:
+        return BatchFeature(
+            {
+                'input_ids': input_ids,
+                'labels': labels,
+                'token_type_ids': token_type_ids,
+                'attention_mask': attention_mask,
+                'input_audio_embeds': input_audio_embeds,
+                'audio_embed_sizes': audio_embed_sizes,
+                'audio_attention_mask': audio_attention_mask,
+                'input_modes': input_modes,
+            }
+        )
+
+def pad_sequence(sequences, padding_side='left', padding_value=0):
+    """
+    Pad a list of sequences to the same length.
+    sequences: list of tensors in [seq_len, *] shape
+    """
+    assert padding_side in ['right', 'left']
+    max_size = sequences[0].size()
+    trailing_dims = max_size[1:]
+    max_len = max(len(seq) for seq in sequences)
+    batch_size = len(sequences)
+    output = sequences[0].new_full((batch_size, max_len) + trailing_dims, padding_value)
+    for i, seq in enumerate(sequences):
+        length = seq.size(0)
+        if padding_side == 'right':
+            output.data[i, :length] = seq
+        else:
+            output.data[i, -length:] = seq
+    return output
+
+def cat_with_pad(tensors, dim, padding_value=0):
+    """
+    cat along dim, while pad to max for all other dims
+    """
+    ndim = tensors[0].dim()
+    assert all(
+        t.dim() == ndim for t in tensors[1:]
+    ), 'All tensors must have the same number of dimensions'
+
+    out_size = [max(t.shape[i] for t in tensors) for i in range(ndim)]
+    out_size[dim] = sum(t.shape[dim] for t in tensors)
+    output = tensors[0].new_full(out_size, padding_value)
+
+    index = 0
+    for t in tensors:
+        # Create a slice list where every dimension except dim is full slice
+        slices = [slice(0, t.shape[d]) for d in range(ndim)]
+        # Update only the concat dimension slice
+        slices[dim] = slice(index, index + t.shape[dim])
+
+        output[slices] = t
+        index += t.shape[dim]
+
+    return output
+
+
+
+class MultiturnAudioDataset(BaseAudioDataset):
+    def __init__(self, processor, split="train", sampling_rate=16000,json_path="",text_only=False, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        from llamafactory.data.template import Llama2Template,parse_template
+        from llamafactory.data.formatter import EmptyFormatter, FunctionFormatter, StringFormatter, ToolFormatter
+        from llamafactory.data.mm_plugin import get_mm_plugin
+        import json 
+        self.train=False
+        self.text_only=text_only
+        with open(json_path) as f:
+            js_data = json.load(f)
+        if split=='train':
+            self.train=True
+            js_data = js_data[:int(len(js_data)*0.8)]
+        else:
+            js_data = js_data[-int(len(js_data)*0.2):]
+        for conv in js_data:
+            for mess in conv['conversations']:
+                if 'audio_path' in mess:
+                    mess['audio_path'] = mess['audio_path'].replace('/home/jeff/codes/llm/InCar/srdc_generate_tts/','/mnt/jeff/InCar/data/multiturn_data/')
+        default_system = ""#"""You are a helpful assistant that determines how to solve problems based on user needs and converts user speech into text.\n"""
+        self.template=Llama2Template(
+            format_user=StringFormatter(slots=["<start_of_turn>user\n{{content}}<end_of_turn>\n<start_of_turn>model\n"]),
+            format_assistant=StringFormatter(slots=["{{content}}<end_of_turn>\n"]),
+            format_system=StringFormatter(slots=["{{content}}\n\n"]),
+            format_function=FunctionFormatter(slots=["{{content}}", {"eos_token"}], tool_format="default"),
+            format_tools = ToolFormatter(tool_format="default"),
+            format_observation=StringFormatter(
+                slots=["<start_of_turn>tool\n{{content}}<end_of_turn>\n<start_of_turn>model\n"]
+            ),
+            default_system=default_system,
+            thought_words=("<think>", "</think>"),
+            efficient_eos=False,
+            replace_eos=False,
+            replace_jinja_template=False,
+            format_prefix=EmptyFormatter(slots=[{"bos_token"}]),
+            stop_words=["<end_of_turn>"],
+            mm_plugin=get_mm_plugin(name="base"),
+            enable_thinking=False
+        )
+
+        self.set_dataset_name(f"MultiturnCostumData")
+        
+        
+        self.data = []
+        self.text_only_data = []
+        for conv in js_data:
+            tools = conv['tools'] if 'tools' in conv else ""
+            system = conv['system'] if 'system' in conv else default_system
+            tmp = {
+                'tools':tools,
+                'system':system,
+                'messages':[],
+            }
+            for i,mess in enumerate(conv['conversations']):
+                tmp['messages'].append(mess)
+                if mess['from']=='human':
+                    tmp['messages'].append(conv['conversations'][i+1])
+                    d = deepcopy(tmp)
+                    d['audio_array'] = torchaudio.load(mess['audio_path'])[0][0]
+                    self.data.append(d)
+                    if self.text_only:
+                        self.text_only_data.append(deepcopy(tmp))
+                    tmp['messages'].pop()
+                elif mess['from']=='observation':
+                    tmp['messages'].append(conv['conversations'][i+1])
+                    d = deepcopy(tmp)
+                    self.text_only_data.append(d)
+                    tmp['messages'].pop()
+        if text_only:
+            self.data=self.text_only_data
+            
+
+    def prepare_multiturn_model_inputs(self, audio_array, messages, system="", tools=""):
+        ANSWER_SUFFIX = "<end_of_turn>"
+        prompt = ""
+        answer_text = ""
+        user_transcribe = ""
+        audio_paths = []
+        for i, message in enumerate(messages):
+            elements = []
+            
+            system_text = ""
+            if i == 0:
+                elements += self.template.format_prefix.apply()
+                if system or tools:
+                    tool_text = self.template.format_tools.apply(content=tools)[0] if tools else ""
+                    system_text = self.template.format_system.apply(content=(system + tool_text))[0]
+
+            if message["from"] == "human":
+                if i==len(messages)-2 and not self.text_only:
+                    user_transcribe =  message["value"]
+                    elements += self.template.format_user.apply(content=system_text+'<start_of_audio>')
+                else:
+                    elements += self.template.format_user.apply(content=system_text + message["value"])
+                audio_paths.append(message['audio_path'])
+            elif message["from"] == "gpt":
+                elements += self.template.format_assistant.apply(content=message["value"])
+            elif message["from"] == "observation":
+                elements += self.template.format_observation.apply(content=message["value"])
+            elif message["from"] == "function_call":
+                elements += self.template.format_function.apply(content=message["value"])
+            else:
+                raise NotImplementedError("Unexpected role: {}".format(message["from"]))
+            
+            
+            for elem in elements:
+                ele_str = ""
+                if isinstance(elem, str):
+                    ele_str=elem
+                elif isinstance(elem, set):
+                    if "bos_token" in elem and self.processor.tokenizer.bos_token_id is not None:
+                        ele_str = self.processor.tokenizer.bos_token
+                    elif "eos_token" in elem and self.processor.tokenizer.eos_token_id is not None:
+                        ele_str = self.processor.tokenizer.eos_token
+                if i == len(messages)-1:
+                    answer_text+=ele_str
+                else:
+                    prompt+=ele_str
+            
+
+        if type(audio_array)!=type(None):
+            inputs = self.processor(
+                text=prompt, 
+                audio=[audio_array], 
+                add_special_tokens=False, 
+                return_tensors='pt'
+            )
+            answer = "\nUser transcribe is : {};\nGPT output is : {}{}".format(user_transcribe,answer_text,ANSWER_SUFFIX)
+        else:
+            inputs = self.processor(
+                text=prompt, 
+                audio=None, 
+                add_special_tokens=False, 
+                return_tensors='pt'
+            )
+            answer = f"{answer_text}{ANSWER_SUFFIX}"
+        # print('user_transcribe',user_transcribe)
+        # print('answer_text', answer)
+        # print('prompt',prompt)
+        answer_ids = self.processor.tokenizer(answer, add_special_tokens=False, return_tensors='pt').input_ids
+        
+        if self.debug:
+            self.debug = False
+            task_type = 'AST' if hasattr(self, 'ast') and self.ast else 'ASR'
+            lang_info = f" - {self.lang}" if hasattr(self, 'lang') else ""
+            print(f"{task_type}{lang_info}\nPROMPT: {prompt}\nINPUT: {self.processor.decode(inputs.input_ids[0], skip_special_tokens=False)}\nANSWER: {self.processor.decode(answer_ids[0], skip_special_tokens=False)}\n")
+            print(f"INPUT_MODE: {inputs.input_modes[0].item()}")
+        
+        if self.training:
+            input_ids = torch.cat([inputs.input_ids, answer_ids], dim=1)
+            labels = torch.full_like(input_ids, _IGNORE_INDEX)
+            labels[:, -answer_ids.shape[1]:] = answer_ids
+            padding = torch.zeros((inputs.token_type_ids.shape[0], answer_ids.shape[1]))
+            token_type_ids = torch.cat([inputs.token_type_ids, padding], dim=1)
+        else:
+            input_ids = inputs.input_ids
+            labels = answer_ids
+            token_type_ids = inputs.token_type_ids
+        if type(audio_array)!=type(None):
+            if not self.train:
+                return {
+                    "audio_path": audio_paths,
+                    'input_ids': input_ids,
+                    'labels': labels,
+                    'token_type_ids': token_type_ids,
+                    'input_audio_embeds': inputs.input_audio_embeds,
+                    'audio_embed_sizes': inputs.audio_embed_sizes,
+                    'input_modes': inputs.input_modes,
+                }
+            else:
+                return {
+                    'input_ids': input_ids,
+                    'labels': labels,
+                    'token_type_ids': token_type_ids,
+                    'input_audio_embeds': inputs.input_audio_embeds,
+                    'audio_embed_sizes': inputs.audio_embed_sizes,
+                    'input_modes': inputs.input_modes,
+                }
+        else:
+            return {
+                'input_ids': input_ids,
+                'labels': labels,
+                'token_type_ids': token_type_ids,
+                'input_audio_embeds': None,
+                'audio_embed_sizes': None,
+                'input_modes': inputs.input_modes,
+            }
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        return self.prepare_multiturn_model_inputs(
+            audio_array=data["audio_array"] if "audio_array" in data else None,
+            messages=data['messages'],
+            system=data["system"],
+            tools=data["tools"]
+        )
+
+
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false" 
+
+INSTRUCTION = {
+    "ast": [
+        "Translate the audio to {0}.",
+        "Translate the audio clip into {0}.",
+        "Based on the attached audio, generate a comprehensive {0} translation of the spoken content.",
+        "Translate the provided audio file into {0}.",
+        "Convert the audio speech to {0} text.",
+        "Write an {0} translation of the audio file.",
+        "Translate spoken words from the audio into {0}.",
+        "Create an {0} version of the audio content.",
+        "Produce an accurate {0} translation of the audio.",
+        "Extract speech from the audio and translate it to {0}.",
+        "Turn the audio into readable {0} text.",
+        "Write all spoken content from the audio in {0}.",
+        "Generate an {0} translation of the speech in the file.",
+        "Convert the recording into {0} text.",
+        "Accurately translate the audio recording to {0}.",
+        "Write down dialogue from the given audio in {0}.",
+        "Translate all speech in this audio file to {0}.",
+        "Create an accurate {0} version of the speech.",
+        "Perform a complete {0} translation of the audio."
+    ],
+    "asr": [
+        "Transcribe the audio clip into text.",
+        "Based on the attached audio, generate a comprehensive text transcription of the spoken content.",
+        "Transcribe the provided audio file into text.",
+        "Convert the audio speech to text.",
+        "Write a transcript of the audio file.",
+        "Transcribe spoken words from the audio.",
+        "Create a text version of the audio content.",
+        "Produce a verbatim transcript of the audio.",
+        "Extract and transcribe speech from the audio.",
+        "Turn the audio into readable text.",
+        "Write all spoken words from the audio.",
+        "Generate a transcript of the speech in the file.",
+        "Convert the recording into a text transcript.",
+        "Accurately transcribe the audio recording.",
+        "Write down dialogue from the given audio.",
+        "Transcribe all speech in this audio file.",
+        "Create an accurate text version of the speech.",
+        "Perform a complete transcription of the audio."
+    ],
+}

cpp/convert_onnx.ipynb

@@ -0,0 +1,767 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/foxconnhy/miniconda3/envs/llamafactory/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "/home/jeff/.cache/huggingface/modules/transformers_modules/gemma_v1/speech_conformer_encoder.py:2798: FutureWarning: Please specify CheckpointImpl.NO_REENTRANT as CheckpointImpl.REENTRANT will soon be removed as the default and eventually deprecated.\n",
+      "  lambda i: encoder_checkpoint_wrapper(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "######################## speech lora #############\n",
+      "######################## text lora #############\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:01<00:00,  1.80it/s]\n",
+      "Some weights of Gemma3OmniForConditionalGeneration were not initialized from the model checkpoint at /mnt/data-2t/jeff/codes/llm/cpp/gemma_v1 and are newly initialized: ['language_model.model.base_model.model.layers.0.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.0.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.0.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.0.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.0.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.0.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.0.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.0.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.0.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.0.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.0.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.0.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.0.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.0.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.1.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.1.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.1.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.1.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.1.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.1.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.1.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.1.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.1.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.1.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.1.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.1.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.1.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.1.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.10.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.10.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.10.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.10.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.10.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.10.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.10.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.10.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.10.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.10.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.10.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.10.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.10.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.10.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.11.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.11.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.11.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.11.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.11.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.11.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.11.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.11.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.11.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.11.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.11.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.11.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.11.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.11.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.12.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.12.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.12.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.12.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.12.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.12.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.12.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.12.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.12.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.12.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.12.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.12.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.12.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.12.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.13.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.13.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.13.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.13.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.13.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.13.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.13.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.13.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.13.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.13.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.13.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.13.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.13.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.13.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.14.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.14.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.14.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.14.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.14.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.14.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.14.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.14.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.14.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.14.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.14.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.14.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.14.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.14.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.15.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.15.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.15.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.15.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.15.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.15.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.15.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.15.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.15.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.15.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.15.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.15.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.15.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.15.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.16.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.16.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.16.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.16.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.16.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.16.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.16.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.16.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.16.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.16.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.16.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.16.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.16.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.16.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.17.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.17.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.17.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.17.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.17.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.17.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.17.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.17.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.17.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.17.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.17.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.17.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.17.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.17.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.18.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.18.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.18.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.18.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.18.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.18.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.18.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.18.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.18.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.18.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.18.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.18.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.18.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.18.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.19.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.19.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.19.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.19.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.19.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.19.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.19.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.19.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.19.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.19.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.19.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.19.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.19.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.19.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.2.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.2.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.2.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.2.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.2.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.2.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.2.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.2.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.2.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.2.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.2.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.2.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.2.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.2.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.20.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.20.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.20.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.20.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.20.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.20.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.20.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.20.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.20.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.20.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.20.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.20.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.20.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.20.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.21.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.21.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.21.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.21.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.21.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.21.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.21.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.21.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.21.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.21.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.21.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.21.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.21.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.21.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.22.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.22.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.22.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.22.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.22.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.22.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.22.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.22.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.22.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.22.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.22.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.22.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.22.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.22.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.23.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.23.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.23.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.23.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.23.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.23.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.23.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.23.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.23.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.23.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.23.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.23.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.23.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.23.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.24.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.24.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.24.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.24.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.24.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.24.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.24.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.24.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.24.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.24.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.24.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.24.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.24.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.24.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.25.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.25.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.25.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.25.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.25.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.25.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.25.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.25.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.25.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.25.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.25.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.25.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.25.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.25.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.26.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.26.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.26.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.26.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.26.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.26.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.26.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.26.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.26.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.26.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.26.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.26.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.26.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.26.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.27.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.27.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.27.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.27.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.27.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.27.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.27.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.27.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.27.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.27.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.27.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.27.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.27.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.27.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.28.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.28.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.28.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.28.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.28.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.28.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.28.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.28.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.28.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.28.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.28.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.28.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.28.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.28.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.29.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.29.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.29.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.29.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.29.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.29.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.29.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.29.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.29.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.29.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.29.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.29.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.29.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.29.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.3.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.3.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.3.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.3.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.3.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.3.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.3.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.3.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.3.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.3.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.3.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.3.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.3.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.3.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.30.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.30.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.30.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.30.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.30.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.30.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.30.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.30.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.30.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.30.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.30.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.30.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.30.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.30.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.31.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.31.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.31.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.31.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.31.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.31.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.31.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.31.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.31.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.31.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.31.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.31.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.31.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.31.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.32.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.32.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.32.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.32.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.32.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.32.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.32.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.32.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.32.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.32.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.32.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.32.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.32.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.32.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.33.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.33.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.33.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.33.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.33.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.33.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.33.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.33.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.33.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.33.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.33.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.33.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.33.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.33.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.4.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.4.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.4.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.4.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.4.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.4.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.4.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.4.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.4.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.4.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.4.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.4.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.4.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.4.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.5.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.5.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.5.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.5.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.5.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.5.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.5.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.5.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.5.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.5.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.5.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.5.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.5.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.5.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.6.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.6.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.6.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.6.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.6.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.6.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.6.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.6.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.6.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.6.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.6.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.6.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.6.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.6.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.7.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.7.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.7.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.7.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.7.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.7.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.7.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.7.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.7.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.7.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.7.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.7.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.7.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.7.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.8.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.8.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.8.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.8.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.8.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.8.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.8.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.8.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.8.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.8.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.8.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.8.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.8.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.8.self_attn.v_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.9.mlp.down_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.9.mlp.down_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.9.mlp.gate_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.9.mlp.gate_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.9.mlp.up_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.9.mlp.up_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.9.self_attn.k_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.9.self_attn.k_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.9.self_attn.o_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.9.self_attn.o_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.9.self_attn.q_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.9.self_attn.q_proj.lora_B.text.weight', 'language_model.model.base_model.model.layers.9.self_attn.v_proj.lora_A.text.weight', 'language_model.model.base_model.model.layers.9.self_attn.v_proj.lora_B.text.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
+      "Using a slow image processor as `use_fast` is unset and a slow processor was saved with this model. `use_fast=True` will be the default behavior in v4.52, even if the model was saved with a slow processor. This will result in minor differences in outputs. You'll still be able to use a slow processor with `use_fast=False`.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from io import BytesIO\n",
+    "import torch\n",
+    "import numpy as np\n",
+    "from transformers import AutoModel, AutoProcessor, BatchFeature,Gemma3ForCausalLM,Gemma3Processor\n",
+    "\n",
+    "# converter = opencc.OpenCC('s2tw.json')\n",
+    "\n",
+    "model_id = \"/mnt/data-2t/jeff/codes/llm/cpp/gemma_v1\"\n",
+    "revision = \"main\" #\"v1.0\"\n",
+    "\n",
+    "model = AutoModel.from_pretrained(\n",
+    "    model_id, device_map=\"cpu\", revision = revision, trust_remote_code=True\n",
+    ").eval()\n",
+    "\n",
+    "processor = AutoProcessor.from_pretrained(\n",
+    "    model_id, revision = revision, trust_remote_code=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Sequential(\n",
+       "  (0): Linear(in_features=1024, out_features=2560, bias=True)\n",
+       "  (1): GELU(approximate='none')\n",
+       "  (2): Linear(in_features=2560, out_features=2560, bias=True)\n",
+       ")"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.audio_tower\n",
+    "model.audio_projector"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 179,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ASRDataset import *\n",
+    "pickup_dataset = MultiturnAudioDataset(split='train',processor=processor,json_path='/mnt/data-2t/jeff/codes/llm/cpp/sample_data/pickup_processed.json')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 180,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([1, 256, 80])\n",
+      "torch.Size([1, 217, 80])\n",
+      "torch.Size([1, 77, 80])\n",
+      "torch.Size([1, 580, 80])\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(len(pickup_dataset)):\n",
+    "    inp = pickup_dataset.__getitem__(i)\n",
+    "    print(inp['input_audio_embeds'].shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([1, 100, 2560])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inp = pickup_dataset.__getitem__(3)\n",
+    "fea,mask = model.audio_tower(inp['input_audio_embeds'],torch.ones(inp['input_audio_embeds'].shape[:2]))\n",
+    "model.audio_projector(fea).shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch \n",
+    "import torch.nn as nn\n",
+    "from speech_conformer_encoder import ConformerEncoder\n",
+    "class Gemma3AudioEncoder(nn.Module):\n",
+    "    def __init__(self,):\n",
+    "        super().__init__()\n",
+    "        audio_config = model.config.audio_config.to_diff_dict()\n",
+    "        for item in ['transformers_version', 'model_type', 'torch_dtype']:\n",
+    "            if item in audio_config:\n",
+    "                audio_config.pop(item)\n",
+    "        # self.audio_tower = model.audio_tower\n",
+    "        # self.audio_projector = model.audio_projector\n",
+    "        self.audio_tower = ConformerEncoder(**audio_config)#model.audio_tower\n",
+    "        self.audio_projector = nn.Sequential(\n",
+    "            nn.Linear(in_features=1024, out_features=2560, bias=True),\n",
+    "            nn.GELU(approximate='none'),\n",
+    "            nn.Linear(in_features=2560, out_features=2560, bias=True))#model.audio_projector\n",
+    "    def forward(self,x,mask):\n",
+    "        # mask = torch.ones(x.shape[:2])\n",
+    "        x,_ = self.audio_tower(x,mask)\n",
+    "        x = self.audio_projector(x)\n",
+    "        return x\n",
+    "audio_encoder = Gemma3AudioEncoder()\n",
+    "import copy\n",
+    "audio_encoder.audio_tower.encoder_embedding=copy.deepcopy(model.audio_tower.encoder_embedding)\n",
+    "audio_encoder.audio_projector.load_state_dict(model.audio_projector.state_dict())\n",
+    "audio_encoder.audio_tower.load_state_dict(model.audio_tower.state_dict())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import onnx\n",
+    "import onnxruntime as ort\n",
+    "import onnxscript\n",
+    "import os\n",
+    "import requests\n",
+    "import shutil\n",
+    "import soundfile\n",
+    "import subprocess\n",
+    "import sys\n",
+    "import torch\n",
+    "\n",
+    "from onnx import helper, numpy_helper, TensorProto\n",
+    "from onnxruntime_genai.models.builder import create_model\n",
+    "from onnxruntime.transformers.dynamo_onnx_helper import DynamoOnnxHelper\n",
+    "from onnxscript import ir\n",
+    "from torch.export import Dim, export\n",
+    "def build_speech(outputdir='./onnx_files'):\n",
+    "    # TorchScript export\n",
+    "    dummy_inputs = (\n",
+    "        torch.randn((1,97,80)),\n",
+    "        torch.ones((1,97))\n",
+    "        #inputs[\"input_audio_embeds\"],   # audio_embeds: torch.FloatTensor\n",
+    "        #inputs[\"audio_attention_mask\"], # audio_attention_mask: torch.BoolTensor\n",
+    "        # inputs[\"audio_embed_sizes\"],    # audio_sizes: torch.LongTensor\n",
+    "        # inputs[\"input_mode\"],           # audio_projection_mode: int\n",
+    "    )\n",
+    "    filename = \"phi-4-mm-speech.onnx\"\n",
+    "\n",
+    "    temp_folder_1 = os.path.join(outputdir, \"speech_init_export\")\n",
+    "    os.makedirs(temp_folder_1, exist_ok=True)\n",
+    "\n",
+    "    fpath_1 = os.path.join(temp_folder_1, filename)\n",
+    "    torch._dynamo.config.capture_scalar_outputs = True\n",
+    "    onnx_program = torch.onnx.export(audio_encoder, dummy_inputs, fpath_1,\n",
+    "                                     input_names=[\"audio_embeds\", \"audio_attention_mask\"], \n",
+    "                                     output_names=[\"audio_features\"],\n",
+    "                                     opset_version=20,\n",
+    "                                     dynamic_axes={\n",
+    "                                        \"audio_embeds\": {0:'B',1: \"L\"},\n",
+    "                                        \"audio_attention_mask\": {0:'B',1: \"L\"},\n",
+    "                                    },\n",
+    "                                     )\n",
+    "\n",
+    "build_speech()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import onnxruntime as ort\n",
+    "import numpy as np\n",
+    "ort_sess = ort.InferenceSession(\"/mnt/data-2t/jeff/codes/llm/cpp/onnx_files/speech_init_export/phi-4-mm-speech.onnx\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(2, 111, 2560)"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "from tqdm import tqdm\n",
+    "import torch\n",
+    "import numpy as np\n",
+    "a=[]\n",
+    "# for i in tqdm(range(10000)):\n",
+    "#     try:\n",
+    "ort_sess.run(None, {\"audio_embeds\": np.array(torch.randn(1,97,80),dtype=np.float32),\n",
+    "                    # \"audio_attention_mask\":np.ones((1,97),dtype=np.float32)\n",
+    "                    }\n",
+    "                    )\n",
+    "    #     print(i)\n",
+    "    #     a.append(i)\n",
+    "    # except:\n",
+    "    #     pass\n",
+    "ort_sess.run(None, {\"audio_embeds\": np.array(torch.randn(2,888,80),dtype=np.float32),\n",
+    "                    # \"audio_attention_mask\":np.ones((2,97),dtype=np.float32)\n",
+    "                    }\n",
+    "                    )[0].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Python inference time check"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "total = 0\n",
+    "_mel = speechlib_mel(16000, 512, 80, fmin=None, fmax=16000//2-80-230).T\n",
+    "for i in range(100):\n",
+    "    now = time.time()\n",
+    "    inp = np.random.randn(np.random.randint(16240, 48240)).reshape(1,-1)#np.array(torch.randn(1,np.random.randint(100,300),80),dtype=np.float32)\n",
+    "    inp = _extract_features(inp,16000).reshape(1,-1,80)\n",
+    "    now = time.time()\n",
+    "    # inp = np.array(torch.randn(1,150,80),dtype=np.float32)\n",
+    "    ort_sess.run(None, {\"audio_embeds\": inp,\n",
+    "                        # \"audio_attention_mask\":np.ones((1,97),dtype=np.float32)\n",
+    "                        })\n",
+    "    total += time.time()-now\n",
+    "    \n",
+    "total,total/100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 238,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "24240"
+      ]
+     },
+     "execution_count": 238,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "149*160+400"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 233,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1, 40917)"
+      ]
+     },
+     "execution_count": 233,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.random.randn(np.random.randint(16240, 48240)).reshape(1,-1).shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(10.608245611190796, 0.10608245611190796)"
+      ]
+     },
+     "execution_count": 218,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import time\n",
+    "total = 0\n",
+    "for i in range(100):\n",
+    "    tmp = torch.randn(1,np.random.randint(100,300),80)\n",
+    "    mask = torch.ones(tmp.shape[:2])\n",
+    "    now = time.time()\n",
+    "    audio_encoder(tmp,mask)\n",
+    "    total += time.time()-now\n",
+    "total,total/100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# C++ ERROR check"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 167,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[[ 0.3246,  0.0295,  0.1076,  ..., -0.1125, -0.0894, -0.3800],\n",
+       "         [ 0.3267, -0.2442,  0.2653,  ...,  0.7783, -0.6049, -1.0858],\n",
+       "         [ 0.1797,  0.0438,  0.9673,  ...,  0.5126, -0.5657, -0.7050],\n",
+       "         ...,\n",
+       "         [ 0.0261, -0.0324,  0.0230,  ..., -0.1303,  0.0343,  0.1486],\n",
+       "         [ 0.1655, -0.3327,  0.4232,  ...,  0.0513,  0.4222, -0.3645],\n",
+       "         [ 0.1147, -0.1201,  0.4198,  ...,  0.6170,  0.0838, -0.1409]]],\n",
+       "       grad_fn=<ViewBackward0>)"
+      ]
+     },
+     "execution_count": 167,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inp = pickup_dataset.__getitem__(3)\n",
+    "fea,mask = model.audio_tower(inp['input_audio_embeds'],torch.ones(inp['input_audio_embeds'].shape[:2]))\n",
+    "model.audio_projector(fea)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 201,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[[ 0.13004433, -0.06643961,  0.01333247, ..., -0.05643693,\n",
+       "         -0.23922557,  0.569423  ],\n",
+       "        [-0.75552   , -0.05047493, -0.82725084, ...,  0.32261163,\n",
+       "         -0.14968234, -0.7078437 ],\n",
+       "        [-0.6673857 ,  0.33906737, -0.6191502 , ...,  0.04259709,\n",
+       "         -0.01194861,  0.27635992],\n",
+       "        ...,\n",
+       "        [ 0.02916821, -0.03163592,  0.02736526, ..., -0.12979224,\n",
+       "          0.03317374,  0.15346158],\n",
+       "        [-0.8559882 , -0.5196625 ,  0.2549707 , ...,  0.28192428,\n",
+       "          1.4099622 , -0.15940394],\n",
+       "        [-0.20253824, -0.30478072, -0.6786582 , ...,  0.08860758,\n",
+       "         -0.12145798,  0.525889  ]]], dtype=float32)"
+      ]
+     },
+     "execution_count": 201,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inp = pickup_dataset.__getitem__(0)\n",
+    "res = ort_sess.run(None, {\"audio_embeds\": np.array(inp['input_audio_embeds'],dtype=np.float32),\n",
+    "                    # \"audio_attention_mask\":np.ones((2,97),dtype=np.float32)\n",
+    "                    }\n",
+    "                    )[0]\n",
+    "res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 208,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[[ 0.130969 , -0.0697925,  0.0150866, ..., -0.0559536,\n",
+       "         -0.239062 ,  0.567436 ],\n",
+       "        [-0.753288 , -0.0582227, -0.825365 , ...,  0.320587 ,\n",
+       "         -0.153626 , -0.709664 ],\n",
+       "        [-0.656874 ,  0.342632 , -0.607641 , ...,  0.0383743,\n",
+       "         -0.0218912,  0.269968 ],\n",
+       "        ...,\n",
+       "        [ 0.0291714, -0.0316175,  0.027369 , ..., -0.129825 ,\n",
+       "          0.033166 ,  0.153453 ],\n",
+       "        [-0.854555 , -0.530883 ,  0.258313 , ...,  0.279057 ,\n",
+       "          1.40658  , -0.159066 ],\n",
+       "        [-0.197598 , -0.306157 , -0.67907  , ...,  0.0915015,\n",
+       "         -0.124402 ,  0.52159  ]]])"
+      ]
+     },
+     "execution_count": 208,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f = open('/mnt/data-2t/jeff/codes/llm/cpp/inference/f0.txt')\n",
+    "content = f.readlines()\n",
+    "f.close()\n",
+    "audio_fea_cpp = np.array([float(i) for i in content[0].split(',')]).reshape(1,-1,2560)\n",
+    "audio_fea_cpp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 202,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([[[0.917797, 1.33496 , 1.9894  , ..., 6.60723 , 6.95787 ,\n",
+       "          7.20139 ],\n",
+       "         [0.      , 0.      , 0.      , ..., 5.99914 , 6.11214 ,\n",
+       "          6.40908 ],\n",
+       "         [0.      , 0.      , 0.      , ..., 5.1184  , 5.36291 ,\n",
+       "          5.14623 ],\n",
+       "         ...,\n",
+       "         [0.      , 0.      , 0.      , ..., 6.25256 , 6.29312 ,\n",
+       "          7.05511 ],\n",
+       "         [0.      , 0.      , 0.      , ..., 6.49829 , 6.7198  ,\n",
+       "          7.08144 ],\n",
+       "         [0.      , 0.      , 1.08376 , ..., 5.43068 , 5.97577 ,\n",
+       "          6.35748 ]]]),\n",
+       " tensor([[[0.8826, 1.3054, 1.9652,  ..., 6.6069, 6.9578, 7.2011],\n",
+       "          [0.0000, 0.0000, 0.0000,  ..., 5.9991, 6.1121, 6.4091],\n",
+       "          [0.0000, 0.0000, 0.0000,  ..., 5.1147, 5.3624, 5.1428],\n",
+       "          ...,\n",
+       "          [0.0000, 0.0000, 0.0000,  ..., 6.2526, 6.2931, 7.0548],\n",
+       "          [0.0000, 0.0000, 0.0000,  ..., 6.4981, 6.7198, 7.0807],\n",
+       "          [0.0000, 0.0000, 1.1479,  ..., 5.4311, 5.9743, 6.3568]]]))"
+      ]
+     },
+     "execution_count": 202,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f = open('/mnt/data-2t/jeff/codes/llm/cpp/inference/matrix_output.txt')\n",
+    "txtlines = f.readlines()\n",
+    "f.close()\n",
+    "inp_emb_cpp = np.array([float(i) for l in txtlines for i in l.split(',')]).reshape(1,-1,80)\n",
+    "inp_emb_cpp,pickup_dataset.__getitem__(0)['input_audio_embeds']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Python preprocessor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(353, 80)"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# modify the code : \n",
+    "# 1. input model and input pcm from args.  \n",
+    "# 2. add model input preprocessor by following python code. The wav input of _extract_features which is an audio array\n",
+    "# 3. the onnx model input is [batch,frames,feature size] = [-1,-1,80]\n",
+    "\n",
+    "def _extract_spectrogram(wav, fs):\n",
+    "    \"\"\"Extract spectrogram features from waveform.\n",
+    "    Args:\n",
+    "        wav (1D array): waveform of the input\n",
+    "        fs (int): sampling rate of the waveform, 16000.\n",
+    "    Output:\n",
+    "        log_fbank (2D array): a TxD matrix of log Mel filterbank features.\n",
+    "            D=80, and T is the number of frames.\n",
+    "    \"\"\"\n",
+    "    if wav.ndim > 1:\n",
+    "        wav = np.squeeze(wav)\n",
+    "\n",
+    "    # by default, we extract the mean if stereo\n",
+    "    if len(wav.shape) == 2:\n",
+    "        wav = wav.mean(1)\n",
+    "\n",
+    "    preemphasis = 0.97\n",
+    "    n_fft = 512\n",
+    "    win_length = 400\n",
+    "    hop_length = 160\n",
+    "    fft_window = np.hamming(400)\n",
+    "\n",
+    "    # Spec 1: SpeechLib cut remaining sample insufficient for a hop\n",
+    "    n_batch = (wav.shape[0] - win_length) // hop_length + 1\n",
+    "    # Here we don't use stride_tricks since the input array may not satisfy\n",
+    "    # memory layout requirement and we need writeable output\n",
+    "    # Here we only use list of views before copy to desination\n",
+    "    # so it is more efficient than broadcasting\n",
+    "    y_frames = np.array(\n",
+    "        [wav[_stride : _stride + win_length] for _stride in range(0, hop_length * n_batch, hop_length)],\n",
+    "        dtype=np.float32,\n",
+    "    )\n",
+    "\n",
+    "    # Spec 2: SpeechLib applies preemphasis within each batch\n",
+    "    y_frames_prev = np.roll(y_frames, 1, axis=1)\n",
+    "    y_frames_prev[:, 0] = y_frames_prev[:, 1]\n",
+    "    y_frames = (y_frames - preemphasis * y_frames_prev) * 32768\n",
+    "\n",
+    "    S = np.fft.rfft(fft_window * y_frames, n=n_fft, axis=1).astype(np.complex64)\n",
+    "    spec = np.abs(S).astype(np.float32)\n",
+    "    return spec\n",
+    "def speechlib_mel(sample_rate, n_fft, n_mels, fmin=None, fmax=None):\n",
+    "    \"\"\"Create a Mel filter-bank the same as SpeechLib FbankFC.\n",
+    "\n",
+    "    Args:\n",
+    "        sample_rate (int): Sample rate in Hz. number > 0 [scalar]\n",
+    "        n_fft (int): FFT size. int > 0 [scalar]\n",
+    "        n_mel (int): Mel filter size. int > 0 [scalar]\n",
+    "        fmin (float): lowest frequency (in Hz). If None use 0.0.\n",
+    "            float >= 0 [scalar]\n",
+    "        fmax: highest frequency (in Hz). If None use sample_rate / 2.\n",
+    "            float >= 0 [scalar]\n",
+    "\n",
+    "    Returns\n",
+    "        out (numpy.ndarray): Mel transform matrix\n",
+    "            [shape=(n_mels, 1 + n_fft/2)]\n",
+    "    \"\"\"\n",
+    "\n",
+    "    bank_width = int(n_fft // 2 + 1)\n",
+    "    if fmax is None:\n",
+    "        fmax = sample_rate / 2\n",
+    "    if fmin is None:\n",
+    "        fmin = 0\n",
+    "    assert fmin >= 0, \"fmin cannot be negtive\"\n",
+    "    assert fmin < fmax <= sample_rate / 2, \"fmax must be between (fmin, samplerate / 2]\"\n",
+    "\n",
+    "    def mel(f):\n",
+    "        return 1127.0 * np.log(1.0 + f / 700.0)\n",
+    "\n",
+    "    def bin2mel(fft_bin):\n",
+    "        return 1127.0 * np.log(1.0 + fft_bin * sample_rate / (n_fft * 700.0))\n",
+    "\n",
+    "    def f2bin(f):\n",
+    "        return int((f * n_fft / sample_rate) + 0.5)\n",
+    "\n",
+    "    # Spec 1: FFT bin range [f2bin(fmin) + 1, f2bin(fmax) - 1]\n",
+    "    klo = f2bin(fmin) + 1\n",
+    "    khi = f2bin(fmax)\n",
+    "\n",
+    "    khi = max(khi, klo)\n",
+    "\n",
+    "    # Spec 2: SpeechLib uses trianges in Mel space\n",
+    "    mlo = mel(fmin)\n",
+    "    mhi = mel(fmax)\n",
+    "    m_centers = np.linspace(mlo, mhi, n_mels + 2)\n",
+    "    ms = (mhi - mlo) / (n_mels + 1)\n",
+    "\n",
+    "    matrix = np.zeros((n_mels, bank_width), dtype=np.float32)\n",
+    "    for m in range(0, n_mels):\n",
+    "        left = m_centers[m]\n",
+    "        center = m_centers[m + 1]\n",
+    "        right = m_centers[m + 2]\n",
+    "        for fft_bin in range(klo, khi):\n",
+    "            mbin = bin2mel(fft_bin)\n",
+    "            if left < mbin < right:\n",
+    "                matrix[m, fft_bin] = 1.0 - abs(center - mbin) / ms\n",
+    "\n",
+    "    return matrix\n",
+    "\n",
+    "def _extract_features(wav, fs):\n",
+    "    \"\"\"Extract log filterbank features from waveform.\n",
+    "    Args:\n",
+    "        wav (1D array): waveform of the input\n",
+    "        fs (int): sampling rate of the waveform, 16000 or 8000.\n",
+    "            If fs=8000, the waveform will be resampled to 16000Hz.\n",
+    "    Output:\n",
+    "        log_fbank (2D array): a TxD matrix of log Mel filterbank features.\n",
+    "            D=80, and T is the number of frames.\n",
+    "    \"\"\"\n",
+    "    spec = _extract_spectrogram(wav, fs)\n",
+    "    spec_power = spec**2\n",
+    "\n",
+    "    fbank_power = np.clip(spec_power.dot(_mel), 1.0, None)\n",
+    "    log_fbank = np.log(fbank_power).astype(np.float32)\n",
+    "\n",
+    "    return log_fbank\n",
+    "\n",
+    "## example \n",
+    "## input shape of arr is [1, 56832], output shape will be (353,80)\n",
+    "_mel = speechlib_mel(16000, 512, 80, fmin=None, fmax=16000//2-80-230).T\n",
+    "output = _extract_features(arr,16000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 227,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(256, 80)"
+      ]
+     },
+     "execution_count": 227,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "_mel = speechlib_mel(16000, 512, 80, fmin=None, fmax=16000//2-80-230).T\n",
+    "output = _extract_features(arr,16000)\n",
+    "output.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "256"
+      ]
+     },
+     "execution_count": 228,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(41239-400)//160+1 100~300"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 229,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(16240, 48240)"
+      ]
+     },
+     "execution_count": 229,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "99*160+400,299*160+400"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llamafactory",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

cpp/gemma_v1/ASRDataset.py

@@ -0,0 +1,793 @@
+import datasets
+datasets.config.DOWNLOADED_DATASETS_PATH = "/mnt/jeff/huggingface/data"
+import os
+os.environ['HF_HOME'] = '/mnt/jeff/huggingface'
+
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+import sacrebleu
+
+from datasets import load_dataset
+from torch.utils.data import Dataset, ConcatDataset
+from tqdm import tqdm
+from transformers import (
+    BatchFeature,
+)
+import pandas as pd
+import soundfile as sf
+from datasets import Audio
+import random
+from copy import deepcopy
+import torchaudio
+
+ANSWER_SUFFIX = "<end_of_turn>"
+_IGNORE_INDEX = -100
+class BaseAudioDataset(Dataset):
+    def __init__(self, processor, split, sampling_rate=16000, debug=False):
+        self.processor = processor
+        self.training = "train" in split or 'other' in split
+        self.debug = debug
+        self.sampling_rate = sampling_rate
+        self.name = ""
+        
+    def set_dataset_name(self, name):
+        self.name = name
+
+    @staticmethod
+    def filter_corrupted_files(data, audio_field, text_fields, dataset_name, sampling_rate=16000, debug=True):
+        original_size = len(data)
+        
+        data = data.cast_column(audio_field, Audio(decode=False))
+        
+        def identify_corrupted_files(example):
+            try:
+                sf.read(example[audio_field]["path"])
+                
+                for field in text_fields:
+                    if field in example and example[field].replace('"', '') == "":
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        data = data.filter(identify_corrupted_files, num_proc=16)
+        validated_size = len(data)
+        
+        # Audio Decoding
+        data = data.cast_column(audio_field, Audio(sampling_rate=sampling_rate, decode=True))
+        
+        if debug:
+            print(f"Dataset: {dataset_name}")
+            print(f"Original data nums: {original_size}")
+            print(f"After filtering data nums: {validated_size}")
+            print(f"Filtering ratio: {validated_size/original_size:.2%}")
+            
+        return data
+
+    @staticmethod
+    def filter_by_audio_length(data, audio_field, min_sec=2, max_sec=20, debug=True):
+        original_size = len(data)
+        
+        def filter_audio_by_length(example):
+            try:
+                audio = example[audio_field]['array']
+                channel = 1
+                if hasattr(audio, 'ndim') and audio.ndim > 1:
+                    channel = audio.ndim
+                    audio = audio.squeeze()
+                audio_length = len(audio) / example[audio_field]['sampling_rate'] / channel
+                return min_sec <= audio_length <= max_sec
+            except Exception as e:
+                if debug:
+                    print(f"Error : {str(e)[:100]}... - sample excluded")
+                return False
+        
+        data = data.filter(filter_audio_by_length, num_proc=16)
+        filtered_size = len(data)
+        
+        if debug:
+            print(f"Before Length Filtering data nums: {original_size}")
+            print(f"After Length Filtering data nums: {filtered_size}")
+            print(f"Filtering ratio: {filtered_size/original_size:.2%}")
+            
+        return data
+
+    def prepare_model_inputs(self, audio_array, instruction, answer_text):
+        user_message = {
+            'role': 'user',
+            'content': '<start_of_audio>' + instruction,
+        }
+        prompt = self.processor.tokenizer.apply_chat_template(
+            [user_message], tokenize=False, add_generation_prompt=True, add_bos=True
+        )
+        
+        inputs = self.processor(
+            text=prompt, 
+            audio=[audio_array], 
+            add_special_tokens=False, 
+            return_tensors='pt'
+        )
+        
+        answer = f"{answer_text}{ANSWER_SUFFIX}"
+        answer_ids = self.processor.tokenizer(answer, add_special_tokens=False, return_tensors='pt').input_ids
+        
+        if self.debug:
+            self.debug = False
+            task_type = 'AST' if hasattr(self, 'ast') and self.ast else 'ASR'
+            lang_info = f" - {self.lang}" if hasattr(self, 'lang') else ""
+            print(f"{task_type}{lang_info}\nPROMPT: {prompt}\nINPUT: {self.processor.decode(inputs.input_ids[0], skip_special_tokens=False)}\nANSWER: {self.processor.decode(answer_ids[0], skip_special_tokens=False)}\n")
+            print(f"INPUT_MODE: {inputs.input_modes[0].item()}")
+        
+        if self.training:
+            input_ids = torch.cat([inputs.input_ids, answer_ids], dim=1)
+            labels = torch.full_like(input_ids, _IGNORE_INDEX)
+            labels[:, -answer_ids.shape[1]:] = answer_ids
+            padding = torch.zeros((inputs.token_type_ids.shape[0], answer_ids.shape[1]))
+            token_type_ids = torch.cat([inputs.token_type_ids, padding], dim=1)
+        else:
+            input_ids = inputs.input_ids
+            labels = answer_ids
+            token_type_ids = inputs.token_type_ids
+        
+        return {
+            'input_ids': input_ids,
+            'labels': labels,
+            'token_type_ids': token_type_ids,
+            'input_audio_embeds': inputs.input_audio_embeds,
+            'audio_embed_sizes': inputs.audio_embed_sizes,
+            'input_modes': inputs.input_modes,
+        }
+        
+# Libri Speech Dataset Class
+class LibriSpeechDataset(BaseAudioDataset):
+    def __init__(self, processor, subset, split, sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name(f"LibriSpeech_{subset}")
+        # only ASR
+        self.ast = False
+        self.lang = "en"
+        
+        # load dataset
+        self.data = load_dataset("/mnt/jeff/InCar/data/librispeech_asr",
+                            subset,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+            
+        # Instruction Setting
+        self.instruction = random.choice(INSTRUCTION["asr"])
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        # Libri Speech is only for ASR
+        answer_text = data["text"].replace('"', '')
+        
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            self.instruction,
+            answer_text
+        )
+    
+# common_voice_16_1 dataset
+class CommonVoiceDataset(BaseAudioDataset):
+    def __init__(self, processor, split, source_lang, sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name(f"CommonVoice_{source_lang}")
+        # only ASR
+        self.ast = False
+        self.lang=source_lang
+        
+        # load dataset
+        if source_lang=="zh-TW":
+            data_path = "/mnt/jeff/InCar/data/common_voice_16_1"
+        else:
+            data_path = "/mnt/jeff/InCar/data/common_voice_17_0"
+        self.data = load_dataset(data_path,
+                            source_lang,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        def prepare_dataset(batch):
+            """Function to preprocess the dataset with the .map method"""
+            transcription = batch["sentence"]
+            
+            if transcription.startswith('"') and transcription.endswith('"'):
+                # we can remove trailing quotation marks as they do not affect the transcription
+                transcription = transcription[1:-1]
+            
+            if transcription[-1] not in [".", "?", "!"]:
+                # append a full-stop to sentences that do not end in punctuation
+                transcription = transcription + "."
+            
+            batch["sentence"] = transcription
+            
+            return batch
+
+        
+        import opencc
+        converter = opencc.OpenCC('s2tw.json')
+        def To_zhTW(batch):
+            
+            transcription = converter.convert(batch["sentence"])
+            batch["sentence"] = transcription
+            
+            return batch
+        self.data = self.data.map(prepare_dataset, desc="preprocess dataset")
+        if source_lang=='zh-CN':
+            self.data = self.data.map(To_zhTW, desc="preprocess dataset To_zhTW")
+        
+        
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+
+        if source_lang == "zh-TW" and split=='train':
+            import torchaudio
+            from torchaudio import transforms
+            import copy
+            import pickle
+            import os
+            def subsample(batch):
+                batch['audio']['array']=torchaudio.functional.resample(torch.FloatTensor(batch['audio']['array']), orig_freq=batch['audio']['sampling_rate'], new_freq=16000)
+                batch['audio']['sampling_rate']=16000
+                return batch
+            def TW_data_augment_fast(batch):
+                speed_perturb_fast = transforms.SpeedPerturbation(batch['audio']['sampling_rate'], [1.1])
+                new_array_fast = speed_perturb_fast(torch.FloatTensor(batch['audio']['array']))[0]
+                batch['audio']['array'] = new_array_fast
+                return batch
+            def TW_data_augment_slow(batch):
+                speed_perturb_slow = transforms.SpeedPerturbation(batch['audio']['sampling_rate'], [0.9])
+                new_array_slow = speed_perturb_slow(torch.FloatTensor(batch['audio']['array']))[0]
+                batch['audio']['array'] = new_array_slow
+                return batch
+            # data = self.data.map(subsample, num_proc=1, desc="subsample")
+            fast_path = '/mnt/jeff/InCar/data/tw_fast.pkl'
+            if not os.path.exists(fast_path):
+                data_fast = self.data.map(TW_data_augment_fast, num_proc=1, desc="augment fast")
+                with open(fast_path,'wb') as f:
+                    pickle.dump(data_fast,f)
+            else:
+                with open(fast_path,'rb') as f:
+                    data_fast=pickle.load(f)
+            
+            slow_path = '/mnt/jeff/InCar/data/data_slow.pkl'
+            if not os.path.exists(slow_path):
+                data_slow = self.data.map(TW_data_augment_slow, num_proc=1, desc="augment slow")
+                with open(slow_path,'wb') as f:
+                    pickle.dump(data_slow,f)
+            else:
+                with open(slow_path,'rb') as f:
+                    data_slow=pickle.load(f)
+            self.data = [d for d in self.data]+[d for d in data_fast]+[d for d in data_slow]
+            
+        # Instruction Setting
+        self.instruction = random.choice(INSTRUCTION["asr"])
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        answer_text = data["sentence"]
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            self.instruction,
+            answer_text
+        )
+    
+
+# Fleurs Dataset Class
+class FleursDataset(BaseAudioDataset):
+    def __init__(self, processor, split, source_lang, target_lang=None, 
+                 mode="asr", sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name("Fleurs")
+        # Mode Setting (ASR or AST)
+        if mode not in ["asr", "ast"]:
+            raise ValueError("mode must be 'asr' or 'ast'.")
+        
+        self.mode = mode
+        self.ast = (mode == "ast")
+        self.source_lang = source_lang
+        
+        # Language name mapping (expand if needed)
+        self.lang_names = {
+            'en_us': 'English', 'cmn_hans': 'Mandarin Chinese'
+        }
+        
+        # load dataset - source language dataset
+        self.data = load_dataset("/mnt/jeff/InCar/data/fleurs",
+                            source_lang,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        import opencc
+        converter = opencc.OpenCC('s2tw.json')
+        def prepare_dataset(batch):
+            transcription = converter.convert(batch["transcription"])
+            batch["transcription"] = transcription
+            
+            return batch
+        if (source_lang=="cmn_hans_cn"):
+            self.data = self.data.map(prepare_dataset, desc="preprocess dataset")
+
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+        self.target_lang_name = ""
+        # When AST mode, load target language dataset.
+        if self.ast:
+            if target_lang is None:
+                raise ValueError("AST mode requires target_lang.")
+                
+            self.target_lang = target_lang
+            self.lang = f"{source_lang}_{target_lang}"
+            
+            # load dataset - target language dataset (for translation)
+            target_data = load_dataset("/mnt/jeff/InCar/data/fleurs",
+                                target_lang,
+                                split=split,
+                                trust_remote_code=True,
+                                cache_dir=Path("/mnt/jeff/InCar/data")
+                                )
+            if target_lang=="cmn_hans_cn":
+                target_data=target_data.map(prepare_dataset, desc="preprocess dataset")
+            source_dict = {item['id']: item for item in self.data}
+            target_dict = {item['id']: item for item in target_data}
+            
+            # only Common ID, add translation fields
+            common_ids = set(source_dict.keys()) & set(target_dict.keys())
+            print(f"FLEURS AST Common data filtering: {len(self.data)} -> {len(common_ids)}")
+            self.data = [
+                {**source_dict[id], 'translation': target_dict[id]['transcription']}
+                for id in common_ids
+            ]
+
+            # Instruction Setting - use target language name
+            self.target_lang_name = self.lang_names.get(target_lang, target_lang.capitalize())
+            self.instruction = random.choice(INSTRUCTION["ast"])
+        else:
+            # ASR mode
+            self.lang = source_lang
+            self.instruction = random.choice(INSTRUCTION["asr"])
+
+        if self.debug:
+            print(f"FLEURS dataset loaded: {self.mode.upper()} mode")
+            print(f"source lang: {source_lang} ({self.lang_names.get(source_lang, source_lang)})")
+            if self.ast:
+                print(f"target lang: {target_lang} ({self.lang_names.get(target_lang, target_lang)})")
+            print(f"dataset size: {len(self.data)}")
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        audio_array = data["audio"]["array"]
+
+        if self.ast:
+            answer_text = data["translation"]
+        else:
+            answer_text = data["transcription"]
+        
+        return self.prepare_model_inputs(
+            audio_array,
+            self.instruction.format(self.target_lang_name),
+            answer_text
+        )
+
+class TWCostumData(BaseAudioDataset):
+    
+    def __init__(self, processor, split="train", sampling_rate=16000,csv_path="", debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        import pandas as pd
+        from datasets import Dataset, Audio 
+        
+
+        df = pd.read_csv(csv_path).fillna('')
+        
+
+        self.set_dataset_name(f"TWCostumData")
+        self.data = Dataset.from_dict(
+                                    {
+                                        "audio": [audio for audio in df['audio']],
+                                        "sentence": [text for text in df['text']]
+                                    }
+                                ).cast_column("audio", Audio(sampling_rate=16000))
+
+        # Instruction Setting
+        self.instruction = random.choice(INSTRUCTION["asr"])
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        answer_text = data["sentence"]
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            self.instruction,
+            answer_text
+        )
+def covost_collate_fn(batch):
+    input_ids_list = []
+    labels_list = []
+    token_type_ids_list = []
+    input_audio_embeds_list = []
+    audio_embed_sizes_list = []
+    audio_attention_mask_list = []
+    input_modes_list = []
+    audio_paths = []
+    for inputs in batch:
+        if 'audio_path' in inputs:
+            audio_paths.append(inputs['audio_path'])
+        input_ids_list.append(inputs['input_ids'][0])
+        labels_list.append(inputs['labels'][0])
+        token_type_ids_list.append(inputs['token_type_ids'][0])
+        if inputs['input_modes']==2:
+            input_audio_embeds_list.append(inputs['input_audio_embeds'])
+            audio_embed_sizes_list.append(inputs['audio_embed_sizes'])
+            audio_attention_mask_list.append(
+                inputs['input_audio_embeds'].new_full((inputs['input_audio_embeds'].size(1),), True, dtype=torch.bool)
+            )
+        # else:
+        #     input_audio_embeds_list.append(None)
+        #     audio_embed_sizes_list.append(None)
+        #     audio_attention_mask_list.append(None)
+        input_modes_list.append(inputs['input_modes'])
+    # try:
+    token_type_ids = pad_sequence(token_type_ids_list, padding_side='left', padding_value=0)
+    input_ids = pad_sequence(input_ids_list, padding_side='left', padding_value=0)
+    labels = pad_sequence(labels_list, padding_side='left', padding_value=0)
+    audio_attention_mask = (
+        pad_sequence(audio_attention_mask_list, padding_side='left', padding_value=False)
+        if len(audio_attention_mask_list) > 1
+        else None
+    )
+    # except Exception as e:
+    #     print(e)
+    #     print(input_ids_list)
+    #     print(labels_list)
+    #     raise
+    attention_mask = (input_ids != 0).long()
+    input_audio_embeds = cat_with_pad(input_audio_embeds_list, dim=0) if len(input_audio_embeds_list)>0 else None
+    audio_embed_sizes = torch.cat(audio_embed_sizes_list) if len(audio_embed_sizes_list)>0 else None
+    input_modes = torch.cat(input_modes_list)
+    if len(audio_paths)>0:
+        return BatchFeature(
+            {
+                "audio_path": audio_paths,
+                'input_ids': input_ids,
+                'labels': labels,
+                'token_type_ids': token_type_ids,
+                'attention_mask': attention_mask,
+                'input_audio_embeds': input_audio_embeds,
+                'audio_embed_sizes': audio_embed_sizes,
+                'audio_attention_mask': audio_attention_mask,
+                'input_modes': input_modes,
+            }
+        )
+    else:
+        return BatchFeature(
+            {
+                'input_ids': input_ids,
+                'labels': labels,
+                'token_type_ids': token_type_ids,
+                'attention_mask': attention_mask,
+                'input_audio_embeds': input_audio_embeds,
+                'audio_embed_sizes': audio_embed_sizes,
+                'audio_attention_mask': audio_attention_mask,
+                'input_modes': input_modes,
+            }
+        )
+
+def pad_sequence(sequences, padding_side='left', padding_value=0):
+    """
+    Pad a list of sequences to the same length.
+    sequences: list of tensors in [seq_len, *] shape
+    """
+    assert padding_side in ['right', 'left']
+    max_size = sequences[0].size()
+    trailing_dims = max_size[1:]
+    max_len = max(len(seq) for seq in sequences)
+    batch_size = len(sequences)
+    output = sequences[0].new_full((batch_size, max_len) + trailing_dims, padding_value)
+    for i, seq in enumerate(sequences):
+        length = seq.size(0)
+        if padding_side == 'right':
+            output.data[i, :length] = seq
+        else:
+            output.data[i, -length:] = seq
+    return output
+
+def cat_with_pad(tensors, dim, padding_value=0):
+    """
+    cat along dim, while pad to max for all other dims
+    """
+    ndim = tensors[0].dim()
+    assert all(
+        t.dim() == ndim for t in tensors[1:]
+    ), 'All tensors must have the same number of dimensions'
+
+    out_size = [max(t.shape[i] for t in tensors) for i in range(ndim)]
+    out_size[dim] = sum(t.shape[dim] for t in tensors)
+    output = tensors[0].new_full(out_size, padding_value)
+
+    index = 0
+    for t in tensors:
+        # Create a slice list where every dimension except dim is full slice
+        slices = [slice(0, t.shape[d]) for d in range(ndim)]
+        # Update only the concat dimension slice
+        slices[dim] = slice(index, index + t.shape[dim])
+
+        output[slices] = t
+        index += t.shape[dim]
+
+    return output
+
+
+
+class MultiturnAudioDataset(BaseAudioDataset):
+    def __init__(self, processor, split="train", sampling_rate=16000,json_path="",text_only=False, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        from llamafactory.data.template import Llama2Template,parse_template
+        from llamafactory.data.formatter import EmptyFormatter, FunctionFormatter, StringFormatter, ToolFormatter
+        from llamafactory.data.mm_plugin import get_mm_plugin
+        import json 
+        self.train=False
+        self.text_only=text_only
+        with open(json_path) as f:
+            js_data = json.load(f)
+        if split=='train':
+            self.train=True
+            js_data = js_data[:int(len(js_data)*0.8)]
+        else:
+            js_data = js_data[-int(len(js_data)*0.2):]
+        for conv in js_data:
+            for mess in conv['conversations']:
+                if 'audio_path' in mess:
+                    mess['audio_path'] = mess['audio_path'].replace('/home/jeff/codes/llm/InCar/srdc_generate_tts/','/mnt/jeff/InCar/data/multiturn_data/')
+        default_system = ""#"""You are a helpful assistant that determines how to solve problems based on user needs and converts user speech into text.\n"""
+        self.template=Llama2Template(
+            format_user=StringFormatter(slots=["<start_of_turn>user\n{{content}}<end_of_turn>\n<start_of_turn>model\n"]),
+            format_assistant=StringFormatter(slots=["{{content}}<end_of_turn>\n"]),
+            format_system=StringFormatter(slots=["{{content}}\n\n"]),
+            format_function=FunctionFormatter(slots=["{{content}}", {"eos_token"}], tool_format="default"),
+            format_tools = ToolFormatter(tool_format="default"),
+            format_observation=StringFormatter(
+                slots=["<start_of_turn>tool\n{{content}}<end_of_turn>\n<start_of_turn>model\n"]
+            ),
+            default_system=default_system,
+            thought_words=("<think>", "</think>"),
+            efficient_eos=False,
+            replace_eos=False,
+            replace_jinja_template=False,
+            format_prefix=EmptyFormatter(slots=[{"bos_token"}]),
+            stop_words=["<end_of_turn>"],
+            mm_plugin=get_mm_plugin(name="base"),
+        )
+
+        self.set_dataset_name(f"MultiturnCostumData")
+        
+        
+        self.data = []
+        self.text_only_data = []
+        for conv in js_data:
+            tools = conv['tools'] if 'tools' in conv else ""
+            system = conv['system'] if 'system' in conv else default_system
+            tmp = {
+                'tools':tools,
+                'system':system,
+                'messages':[],
+            }
+            for i,mess in enumerate(conv['conversations']):
+                tmp['messages'].append(mess)
+                if mess['from']=='human':
+                    tmp['messages'].append(conv['conversations'][i+1])
+                    d = deepcopy(tmp)
+                    d['audio_array'] = torchaudio.load(mess['audio_path'])[0][0]
+                    self.data.append(d)
+                    if self.text_only:
+                        self.text_only_data.append(deepcopy(tmp))
+                    tmp['messages'].pop()
+                elif mess['from']=='observation':
+                    tmp['messages'].append(conv['conversations'][i+1])
+                    d = deepcopy(tmp)
+                    self.text_only_data.append(d)
+                    tmp['messages'].pop()
+        if text_only:
+            self.data=self.text_only_data
+            
+
+    def prepare_multiturn_model_inputs(self, audio_array, messages, system="", tools=""):
+        ANSWER_SUFFIX = "<end_of_turn>"
+        prompt = ""
+        answer_text = ""
+        user_transcribe = ""
+        audio_paths = []
+        for i, message in enumerate(messages):
+            elements = []
+            
+            system_text = ""
+            if i == 0:
+                elements += self.template.format_prefix.apply()
+                if system or tools:
+                    tool_text = self.template.format_tools.apply(content=tools)[0] if tools else ""
+                    system_text = self.template.format_system.apply(content=(system + tool_text))[0]
+
+            if message["from"] == "human":
+                if i==len(messages)-2 and not self.text_only:
+                    user_transcribe =  message["value"]
+                    elements += self.template.format_user.apply(content=system_text+'<start_of_audio>')
+                else:
+                    elements += self.template.format_user.apply(content=system_text + message["value"])
+                audio_paths.append(message['audio_path'])
+            elif message["from"] == "gpt":
+                elements += self.template.format_assistant.apply(content=message["value"])
+            elif message["from"] == "observation":
+                elements += self.template.format_observation.apply(content=message["value"])
+            elif message["from"] == "function_call":
+                elements += self.template.format_function.apply(content=message["value"])
+            else:
+                raise NotImplementedError("Unexpected role: {}".format(message["from"]))
+            
+            
+            for elem in elements:
+                ele_str = ""
+                if isinstance(elem, str):
+                    ele_str=elem
+                elif isinstance(elem, set):
+                    if "bos_token" in elem and self.processor.tokenizer.bos_token_id is not None:
+                        ele_str = self.processor.tokenizer.bos_token
+                    elif "eos_token" in elem and self.processor.tokenizer.eos_token_id is not None:
+                        ele_str = self.processor.tokenizer.eos_token
+                if i == len(messages)-1:
+                    answer_text+=ele_str
+                else:
+                    prompt+=ele_str
+            
+
+        if type(audio_array)!=type(None):
+            inputs = self.processor(
+                text=prompt, 
+                audio=[audio_array], 
+                add_special_tokens=False, 
+                return_tensors='pt'
+            )
+            answer = "\nUser transcribe is : {};\nGPT output is : {}{}".format(user_transcribe,answer_text,ANSWER_SUFFIX)
+        else:
+            inputs = self.processor(
+                text=prompt, 
+                audio=None, 
+                add_special_tokens=False, 
+                return_tensors='pt'
+            )
+            answer = f"{answer_text}{ANSWER_SUFFIX}"
+        # print('user_transcribe',user_transcribe)
+        # print('answer_text', answer)
+        # print('prompt',prompt)
+        answer_ids = self.processor.tokenizer(answer, add_special_tokens=False, return_tensors='pt').input_ids
+        
+        if self.debug:
+            self.debug = False
+            task_type = 'AST' if hasattr(self, 'ast') and self.ast else 'ASR'
+            lang_info = f" - {self.lang}" if hasattr(self, 'lang') else ""
+            print(f"{task_type}{lang_info}\nPROMPT: {prompt}\nINPUT: {self.processor.decode(inputs.input_ids[0], skip_special_tokens=False)}\nANSWER: {self.processor.decode(answer_ids[0], skip_special_tokens=False)}\n")
+            print(f"INPUT_MODE: {inputs.input_modes[0].item()}")
+        
+        if self.training:
+            input_ids = torch.cat([inputs.input_ids, answer_ids], dim=1)
+            labels = torch.full_like(input_ids, _IGNORE_INDEX)
+            labels[:, -answer_ids.shape[1]:] = answer_ids
+            padding = torch.zeros((inputs.token_type_ids.shape[0], answer_ids.shape[1]))
+            token_type_ids = torch.cat([inputs.token_type_ids, padding], dim=1)
+        else:
+            input_ids = inputs.input_ids
+            labels = answer_ids
+            token_type_ids = inputs.token_type_ids
+        if type(audio_array)!=type(None):
+            if not self.train:
+                return {
+                    "audio_path": audio_paths,
+                    'input_ids': input_ids,
+                    'labels': labels,
+                    'token_type_ids': token_type_ids,
+                    'input_audio_embeds': inputs.input_audio_embeds,
+                    'audio_embed_sizes': inputs.audio_embed_sizes,
+                    'input_modes': inputs.input_modes,
+                }
+            else:
+                return {
+                    'input_ids': input_ids,
+                    'labels': labels,
+                    'token_type_ids': token_type_ids,
+                    'input_audio_embeds': inputs.input_audio_embeds,
+                    'audio_embed_sizes': inputs.audio_embed_sizes,
+                    'input_modes': inputs.input_modes,
+                }
+        else:
+            return {
+                'input_ids': input_ids,
+                'labels': labels,
+                'token_type_ids': token_type_ids,
+                'input_audio_embeds': None,
+                'audio_embed_sizes': None,
+                'input_modes': inputs.input_modes,
+            }
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        return self.prepare_multiturn_model_inputs(
+            audio_array=data["audio_array"] if "audio_array" in data else None,
+            messages=data['messages'],
+            system=data["system"],
+            tools=data["tools"]
+        )
+
+
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false" 
+
+INSTRUCTION = {
+    "ast": [
+        "Translate the audio to {0}.",
+        "Translate the audio clip into {0}.",
+        "Based on the attached audio, generate a comprehensive {0} translation of the spoken content.",
+        "Translate the provided audio file into {0}.",
+        "Convert the audio speech to {0} text.",
+        "Write an {0} translation of the audio file.",
+        "Translate spoken words from the audio into {0}.",
+        "Create an {0} version of the audio content.",
+        "Produce an accurate {0} translation of the audio.",
+        "Extract speech from the audio and translate it to {0}.",
+        "Turn the audio into readable {0} text.",
+        "Write all spoken content from the audio in {0}.",
+        "Generate an {0} translation of the speech in the file.",
+        "Convert the recording into {0} text.",
+        "Accurately translate the audio recording to {0}.",
+        "Write down dialogue from the given audio in {0}.",
+        "Translate all speech in this audio file to {0}.",
+        "Create an accurate {0} version of the speech.",
+        "Perform a complete {0} translation of the audio."
+    ],
+    "asr": [
+        "Transcribe the audio clip into text.",
+        "Based on the attached audio, generate a comprehensive text transcription of the spoken content.",
+        "Transcribe the provided audio file into text.",
+        "Convert the audio speech to text.",
+        "Write a transcript of the audio file.",
+        "Transcribe spoken words from the audio.",
+        "Create a text version of the audio content.",
+        "Produce a verbatim transcript of the audio.",
+        "Extract and transcribe speech from the audio.",
+        "Turn the audio into readable text.",
+        "Write all spoken words from the audio.",
+        "Generate a transcript of the speech in the file.",
+        "Convert the recording into a text transcript.",
+        "Accurately transcribe the audio recording.",
+        "Write down dialogue from the given audio.",
+        "Transcribe all speech in this audio file.",
+        "Create an accurate text version of the speech.",
+        "Perform a complete transcription of the audio."
+    ],
+}

cpp/gemma_v1/added_tokens.json

@@ -0,0 +1,3 @@
+{
+  "<image_soft_token>": 262144
+}

cpp/gemma_v1/chat_template.json

@@ -0,0 +1,3 @@
+{
+  "chat_template": "{{ bos_token }}\n{%- if messages[0]['role'] == 'system' -%}\n    {%- if messages[0]['content'] is string -%}\n        {%- set first_user_prefix = messages[0]['content'] + '\n\n' -%}\n    {%- else -%}\n        {%- set first_user_prefix = messages[0]['content'][0]['text'] + '\n\n' -%}\n    {%- endif -%}\n    {%- set loop_messages = messages[1:] -%}\n{%- else -%}\n    {%- set first_user_prefix = \"\" -%}\n    {%- set loop_messages = messages -%}\n{%- endif -%}\n{%- for message in loop_messages -%}\n    {%- if (message['role'] == 'user') != (loop.index0 % 2 == 0) -%}\n        {{ raise_exception(\"Conversation roles must alternate user/assistant/user/assistant/...\") }}\n    {%- endif -%}\n    {%- if (message['role'] == 'assistant') -%}\n        {%- set role = \"model\" -%}\n    {%- else -%}\n        {%- set role = message['role'] -%}\n    {%- endif -%}\n    {{ '<start_of_turn>' + role + '\n' + (first_user_prefix if loop.first else \"\") }}\n    {%- if message['content'] is string -%}\n        {{ message['content'] | trim }}\n    {%- elif message['content'] is iterable -%}\n        {%- for item in message['content'] -%}\n            {%- if item['type'] == 'image' -%}\n                {{ '<start_of_image>' }}\n            {%- elif item['type'] == 'audio' -%}\n                {{ '<start_of_audio>' }}\n            {%- elif item['type'] == 'text' -%}\n                {{ item['text'] | trim }}\n            {%- endif -%}\n        {%- endfor -%}\n    {%- else -%}\n        {{ raise_exception(\"Invalid content type\") }}\n    {%- endif -%}\n    {{ '<end_of_turn>\n' }}\n{%- endfor -%}\n{%- if add_generation_prompt -%}\n    {{'<start_of_turn>model\n'}}\n{%- endif -%}\n"
+}

cpp/gemma_v1/config.json

@@ -0,0 +1,118 @@
+{
+  "architectures": [
+    "Gemma3OmniForConditionalGeneration"
+  ],
+  "audio_config": {
+    "activation": "swish",
+    "activation_checkpointing": {
+      "interval": 1,
+      "module": "transformer",
+      "offload": false
+    },
+    "attention_dim": 1024,
+    "attention_heads": 16,
+    "batch_norm": false,
+    "bias_in_glu": true,
+    "causal": true,
+    "chunk_size": -1,
+    "cnn_layer_norm": true,
+    "conv_activation": "swish",
+    "conv_glu_type": "swish",
+    "depthwise_multiplier": 1,
+    "depthwise_seperable_out_channel": 1024,
+    "dropout_rate": 0.0,
+    "encoder_embedding_config": {
+      "input_size": 80
+    },
+    "ext_pw_kernel_size": 1,
+    "ext_pw_out_channel": 1024,
+    "input_layer": "nemo_conv",
+    "input_size": 80,
+    "kernel_size": 3,
+    "left_chunk": 18,
+    "linear_units": 1536,
+    "nemo_conv_settings": {
+      "conv_channels": 1024
+    },
+    "num_blocks": 24,
+    "relative_attention_bias_args": {
+      "t5_bias_max_distance": 500,
+      "type": "t5"
+    },
+    "time_reduction": 8
+  },
+  "audio_token_index": 262143,
+  "auto_map": {
+    "AutoConfig": "configuration_gemma3omni.Gemma3OmniConfig",
+    "AutoModel": "modeling_gemma3omni.Gemma3OmniForConditionalGeneration"
+  },
+  "boa_token_index": 256001,
+  "boi_token_index": 255999,
+  "eoa_token_index": 256002,
+  "eoi_token_index": 256000,
+  "eos_token_id": [
+    1,
+    106
+  ],
+  "image_token_index": 262144,
+  "initializer_range": 0.02,
+  "mm_tokens_per_image": 256,
+  "model_type": "gemma3omni",
+  "speech_lora": {
+    "dp": 0.01,
+    "layer": "((layers.*self_attn\\.(q|k|v|o)_proj)|(layers.*mlp\\.(gate|up|down)_proj))",
+    "lora_alpha": 320,
+    "r": 320,
+    "use_rslora": true
+  },
+  "text_lora": {
+    "dp": 0.01,
+    "layer": "((layers.*self_attn\\.(q|k|v|o)_proj)|(layers.*mlp\\.(gate|up|down)_proj))",
+    "lora_alpha": 16,
+    "r": 8,
+    "use_rslora": true
+  },
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "attn_logit_softcapping": null,
+    "cache_implementation": "hybrid",
+    "final_logit_softcapping": null,
+    "head_dim": 256,
+    "hidden_activation": "gelu_pytorch_tanh",
+    "hidden_size": 2560,
+    "initializer_range": 0.02,
+    "intermediate_size": 10240,
+    "max_position_embeddings": 131072,
+    "model_type": "gemma3_text",
+    "num_attention_heads": 8,
+    "num_hidden_layers": 34,
+    "num_key_value_heads": 4,
+    "query_pre_attn_scalar": 256,
+    "rms_norm_eps": 1e-06,
+    "rope_local_base_freq": 10000.0,
+    "rope_scaling": {
+      "factor": 8.0,
+      "rope_type": "linear"
+    },
+    "rope_theta": 1000000.0,
+    "sliding_window": 1024,
+    "sliding_window_pattern": 6,
+    "torch_dtype": "float",
+    "use_cache": true,
+    "vocab_size": 262208
+  },
+  "torch_dtype": "float",
+  "transformers_version": "4.51.3",
+  "use_cache": false,
+  "vision_config": {
+    "hidden_size": 1152,
+    "image_size": 896,
+    "intermediate_size": 4304,
+    "model_type": "siglip_vision_model",
+    "num_attention_heads": 16,
+    "num_hidden_layers": 27,
+    "patch_size": 14,
+    "vision_use_head": false
+  }
+}

cpp/gemma_v1/configuration_gemma3omni.py

@@ -0,0 +1,206 @@
+from typing import Optional
+
+from transformers import AutoConfig, Gemma3TextConfig
+from transformers.configuration_utils import PretrainedConfig
+from transformers.modeling_rope_utils import rope_config_validation
+from transformers.utils import logging
+from transformers.models.siglip import SiglipVisionConfig
+
+
+logger = logging.get_logger(__name__)
+
+class AudioConfig(PretrainedConfig):
+    model_type = "gemma3_audio"
+    
+    def __init__(
+        self,
+        input_size=80,
+        attention_dim=1024,
+        attention_heads=16,
+        num_blocks=24,
+        linear_units=1536,
+        dropout_rate=0.0,
+        kernel_size=3,
+        ext_pw_kernel_size=1,
+        ext_pw_out_channel=1024,
+        depthwise_seperable_out_channel=1024,
+        depthwise_multiplier=1,
+        activation="swish",
+        conv_activation="swish",
+        conv_glu_type="swish",
+        bias_in_glu=True,
+        causal=True,
+        batch_norm=False,
+        cnn_layer_norm=True,
+        time_reduction=8,
+        input_layer="nemo_conv",
+        nemo_conv_settings=None,
+        chunk_size=-1,
+        left_chunk=18,
+        relative_attention_bias_args=None,
+        activation_checkpointing=None,
+        encoder_embedding_config=None,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        
+        self.input_size = input_size
+        self.attention_dim = attention_dim
+        self.attention_heads = attention_heads
+        self.num_blocks = num_blocks
+        self.linear_units = linear_units
+        self.dropout_rate = dropout_rate
+        self.kernel_size = kernel_size
+        self.ext_pw_kernel_size = ext_pw_kernel_size
+        self.ext_pw_out_channel = ext_pw_out_channel
+        self.depthwise_seperable_out_channel = depthwise_seperable_out_channel
+        self.depthwise_multiplier = depthwise_multiplier
+        self.activation = activation
+        self.conv_activation = conv_activation
+        self.conv_glu_type = conv_glu_type
+        self.bias_in_glu = bias_in_glu
+        self.causal = causal
+        self.batch_norm = batch_norm
+        self.cnn_layer_norm = cnn_layer_norm
+        self.time_reduction = time_reduction
+        self.input_layer = input_layer
+        
+        if nemo_conv_settings is None:
+            self.nemo_conv_settings = {"conv_channels": 1024}
+        else:
+            self.nemo_conv_settings = nemo_conv_settings
+            
+        self.chunk_size = chunk_size
+        self.left_chunk = left_chunk
+        
+        if relative_attention_bias_args is None:
+            self.relative_attention_bias_args = {"type": "t5", "t5_bias_max_distance": 500}
+        else:
+            self.relative_attention_bias_args = relative_attention_bias_args
+            
+        if activation_checkpointing is None:
+            self.activation_checkpointing = {"interval": 1, "module": "transformer", "offload": False}
+        else:
+            self.activation_checkpointing = activation_checkpointing
+            
+        if encoder_embedding_config is None:
+            self.encoder_embedding_config = {"input_size": input_size}
+        else:
+            self.encoder_embedding_config = encoder_embedding_config
+    
+
+class Gemma3OmniConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`Gemma3ForConditionalGeneration`]. It is used to instantiate an
+    Gemma3ForConditionalGeneration according to the specified arguments, defining the model architecture. Instantiating a configuration
+    with the defaults will yield a similar configuration to that of the PaliGemma-2B.
+
+    e.g. [google/gemma-3-4b](https://huggingface.co/google/gemma-3-4b)
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+    Args:
+        text_config (`Union[Gemma3TextConfig, dict]`, *optional*):
+            The config object of the text backbone.
+        vision_config (`Union[AutoConfig, dict]`,  *optional*):
+            Custom vision config or dict.
+        audio_config (`Union[AutoConfig, dict]`,  *optional*):
+            Custom audio config or dict.
+        mm_tokens_per_image (`int`, *optional*, defaults to 256):
+            The number of tokens per image embedding.
+        boi_token_index (`int`, *optional*, defaults to 255999):
+            The begin-of-image token index to wrap the image prompt.
+        eoi_token_index (`int`, *optional*, defaults to 256000):
+            The end-of-image token index to wrap the image prompt.
+        image_token_index (`int`, *optional*, defaults to 262144):
+            The image token index to encode the image prompt.
+        audio_token_index (`int`, *optional*, defaults to 262145):
+            The audio token index to encode the audio prompt.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+
+
+    Example:
+
+    ```python
+    >>> from transformers import Gemma3ForConditionalGeneration, Gemma3Config, SiglipVisionConfig, Gemma3TextConfig
+
+    >>> # Initializing a Siglip-like vision config
+    >>> vision_config = SiglipVisionConfig()
+
+    >>> # Initializing a Siglip-like vision config
+    >>> audio_config = AudioConfig()
+
+    >>> # Initializing a Gemma3 Text config
+    >>> text_config = Gemma3TextConfig()
+
+    >>> # Initializing a Gemma3 gemma-3-4b style configuration
+    >>> configuration = Gemma3Config(vision_config, text_config)
+
+    >>> # Initializing a model from the gemma-3-4b style configuration
+    >>> model = Gemma3TextConfig(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "gemma3omni"
+    sub_configs = {
+        "text_config": Gemma3TextConfig,
+        "vision_config": SiglipVisionConfig,
+        "audio_config": AudioConfig,
+    }
+
+    def __init__(
+        self,
+        text_config: Optional[Gemma3TextConfig] = None,
+        vision_config: Optional[SiglipVisionConfig] = None,
+        audio_config: Optional[AudioConfig] = None,
+        mm_tokens_per_image: int = 256,
+        boi_token_index: int = 255_999,
+        eoi_token_index: int = 256_000,
+        boa_token_index: int = 256_001,
+        eoa_token_index: int = 256_002,
+        image_token_index: int = 262_144,
+        audio_token_index: int = 262_143,
+        initializer_range: float = 0.02,
+        **kwargs,
+    ):
+        if text_config is None:
+            text_config = Gemma3TextConfig()
+            logger.info("text_config is None, using default Gemma3TextConfig vision config.")
+        elif isinstance(text_config, dict):
+            text_config = Gemma3TextConfig(**text_config)
+
+        if isinstance(vision_config, dict):
+            vision_config = SiglipVisionConfig(**vision_config)
+        else:
+            vision_config = SiglipVisionConfig()
+            logger.info(
+                "vision_config is None or incompatible with Gemma3VisionConfig intialization. Gemma3 will be limited "
+                "to text tasks."
+            )
+            
+        if isinstance(audio_config, dict):
+            audio_config = AudioConfig(**audio_config)
+        else:
+            audio_config = AudioConfig()
+            logger.info(
+                "audio_config is None or incompatible with Gemma3AudioConfig intialization. Gemma3 will be limited "
+                "to text tasks."
+            )
+
+        self.text_config = text_config
+        self.vision_config = vision_config
+        self.audio_config = audio_config
+        self.mm_tokens_per_image = mm_tokens_per_image
+        self.boi_token_index = boi_token_index
+        self.eoi_token_index = eoi_token_index
+        self.boa_token_index = boa_token_index
+        self.eoa_token_index = eoa_token_index
+        self.image_token_index = image_token_index
+        self.audio_token_index = audio_token_index
+        self.initializer_range = initializer_range
+
+        super().__init__(**kwargs)

cpp/gemma_v1/eval.py

@@ -0,0 +1,635 @@
+from io import BytesIO
+from urllib.request import urlopen
+import soundfile
+import torch
+from datasets import load_dataset, Audio
+import numpy as np
+from transformers import AutoModel, AutoProcessor, BatchFeature
+from tqdm import tqdm
+import json
+import os
+import time
+from datetime import datetime
+from whisper_normalizer.english import EnglishTextNormalizer
+from whisper_normalizer.basic import BasicTextNormalizer
+import sacrebleu
+from jiwer import cer, wer
+from torch.utils.data import Dataset, DataLoader
+import soundfile as sf
+import re
+from pathlib import Path
+import opencc
+converter = opencc.OpenCC('s2tw.json')
+normalizer = {
+    "en_us" : EnglishTextNormalizer(),
+    "other" : BasicTextNormalizer()
+}
+
+model_id = "/mnt/jeff/gemma_test"
+revision = "main" #"v1.0"
+
+model = AutoModel.from_pretrained(
+    model_id, device_map="cuda", revision = revision, trust_remote_code=True
+).eval()
+
+processor = AutoProcessor.from_pretrained(
+    model_id, revision = revision, trust_remote_code=True
+)
+
+results_dir = f"evaluation_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+os.makedirs(results_dir, exist_ok=True)
+
+
+INSTRUCTION = {
+    "ast": "Translate the audio to {0}.",
+    "asr": "Transcribe the audio clip into text.",
+}
+
+class BaseAudioDataset(Dataset):
+    def __init__(self, processor, split, sampling_rate=16000, debug=False):
+        self.processor = processor
+        self.training = "train" in split
+        self.debug = debug
+        self.sampling_rate = sampling_rate
+        self.name = ""
+
+    def set_dataset_name(self, name):
+        self.name = name
+
+    @staticmethod
+    def filter_corrupted_files(data, audio_field, text_fields, dataset_name, sampling_rate=16000, debug=True):
+        original_size = len(data)
+        
+        data = data.cast_column(audio_field, Audio(decode=False))
+        
+        def identify_corrupted_files(example):
+            try:
+                sf.read(example[audio_field]["path"])
+                
+                for field in text_fields:
+                    if example[field].replace('"', '') == "":
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        data = data.filter(identify_corrupted_files, num_proc=16)
+        validated_size = len(data)
+        
+        data = data.cast_column(audio_field, Audio(sampling_rate=sampling_rate, decode=True))
+        
+        
+        return data
+
+    @staticmethod
+    def filter_by_audio_length(data, audio_field, min_sec=2, max_sec=20, debug=True):
+        original_size = len(data)
+        
+        def filter_audio_by_length(example):
+            try:
+                audio = example[audio_field]['array']
+                channel = 1
+                if hasattr(audio, 'ndim') and audio.ndim > 1:
+                    channel = audio.ndim
+                    audio = audio.squeeze()
+                audio_length = len(audio) / example[audio_field]['sampling_rate'] / channel
+                return min_sec <= audio_length <= max_sec
+            except Exception as e:
+                return False
+        
+        data = data.filter(filter_audio_by_length, num_proc=16)
+        filtered_size = len(data)
+
+        return data
+
+    def prepare_model_inputs(self, audio_array, instruction, answer_text):
+        user_message = {
+            'role': 'user',
+            'content': '<start_of_audio>' + instruction,
+        }
+        prompt = self.processor.tokenizer.apply_chat_template(
+            [user_message], tokenize=False, add_generation_prompt=True, add_bos=True
+        )
+        
+        inputs = self.processor(
+            text=prompt, 
+            audio=[audio_array], 
+            add_special_tokens=False, 
+            return_tensors='pt'
+        )
+        
+        input_ids = inputs.input_ids
+        token_type_ids = inputs.token_type_ids
+        
+        return {
+            'input_ids': input_ids,
+            'token_type_ids': token_type_ids,
+            'input_audio_embeds': inputs.input_audio_embeds,
+            'audio_embed_sizes': inputs.audio_embed_sizes,
+            'input_modes': inputs.input_modes,
+            'answer': answer_text,
+        }
+
+
+# Libri Speech Dataset Class
+class LibriSpeechDataset(BaseAudioDataset):
+    def __init__(self, processor, subset, split, sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name(f"LibriSpeech_{subset}")
+        # only ASR
+        self.ast = False
+        self.lang = "en"
+        
+        # load dataset
+        self.data = load_dataset("openslr/librispeech_asr",
+                            subset,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+            
+        # Instruction Setting
+        self.instruction = INSTRUCTION["asr"]
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        # Libri Speech is only for ASR
+        answer_text = data["text"].replace('"', '')
+        
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            INSTRUCTION["asr"],
+            answer_text
+        )
+    
+# common_voice_16_1 dataset
+class CommonVoiceDataset(BaseAudioDataset):
+    def __init__(self, processor, split, source_lang, sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name(f"CommonVoice_{source_lang}")
+        # only ASR
+        self.ast = False
+        self.lang=source_lang
+        
+        # load dataset
+        self.data = load_dataset("mozilla-foundation/common_voice_16_1",
+                            source_lang,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        def prepare_dataset(batch):
+            """Function to preprocess the dataset with the .map method"""
+            transcription = batch["sentence"]
+            
+            if transcription.startswith('"') and transcription.endswith('"'):
+                # we can remove trailing quotation marks as they do not affect the transcription
+                transcription = transcription[1:-1]
+            
+            if transcription[-1] not in [".", "?", "!"]:
+                # append a full-stop to sentences that do not end in punctuation
+                transcription = transcription + "."
+            
+            batch["sentence"] = transcription
+            
+            return batch
+        self.data=self.data.map(prepare_dataset, desc="preprocess dataset")
+        
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+            
+        # Instruction Setting
+        self.instruction = INSTRUCTION["asr"]
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        answer_text = data["sentence"]
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            INSTRUCTION["asr"],
+            answer_text
+        )
+    
+
+# Fleurs Dataset Class
+class FleursDataset(BaseAudioDataset):
+    def __init__(self, processor, split, source_lang, target_lang=None, 
+                 mode="asr", sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name("Fleurs")
+        # Mode Setting (ASR or AST)
+        if mode not in ["asr", "ast"]:
+            raise ValueError("mode must be 'asr' or 'ast'.")
+        
+        self.mode = mode
+        self.ast = (mode == "ast")
+        self.source_lang = source_lang
+        
+        # Language name mapping (expand if needed)
+        self.lang_names = {
+            'en_us': 'English', 'cmn_hans': 'Mandarin Chinese'
+        }
+        
+        # load dataset - source language dataset
+        self.data = load_dataset("google/fleurs",
+                            source_lang,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        def prepare_dataset(batch):
+            import opencc
+            converter = opencc.OpenCC('s2tw.json')
+            if self.ast:
+                translation = converter.convert(batch["translation"])
+                batch["translation"] = translation
+            else:
+                transcription = converter.convert(batch["transcription"])
+                batch["transcription"] = transcription
+            
+            return batch
+        if (source_lang=="cmn_hans_cn" and not self.ast) or (self.ast and target_lang=="cmn_hans_cn"):
+            self.data=self.data.map(prepare_dataset, desc="preprocess dataset")
+
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+        self.target_lang_name = ""
+        # When AST mode, load target language dataset.
+        if self.ast:
+            if target_lang is None:
+                raise ValueError("AST mode requires target_lang.")
+                
+            self.target_lang = target_lang
+            self.lang = f"{source_lang}_{target_lang}"
+            
+            # load dataset - target language dataset (for translation)
+            target_data = load_dataset("google/fleurs",
+                                target_lang,
+                                split=split,
+                                trust_remote_code=True,
+                                cache_dir=Path("/mnt/jeff/InCar/data")
+                                )
+            
+            source_dict = {item['id']: item for item in self.data}
+            target_dict = {item['id']: item for item in target_data}
+            
+            # only Common ID, add translation fields
+            common_ids = set(source_dict.keys()) & set(target_dict.keys())
+            print(f"FLEURS AST Common data filtering: {len(self.data)} -> {len(common_ids)}")
+            self.data = [
+                {**source_dict[id], 'translation': target_dict[id]['transcription']}
+                for id in common_ids
+            ]
+
+            # Instruction Setting - use target language name
+            self.target_lang_name = self.lang_names.get(target_lang, target_lang.capitalize())
+            self.instruction = INSTRUCTION["ast"]
+        else:
+            # ASR mode
+            self.lang = source_lang
+            self.instruction = INSTRUCTION["asr"]
+
+        if self.debug:
+            print(f"FLEURS dataset loaded: {self.mode.upper()} mode")
+            print(f"source lang: {source_lang} ({self.lang_names.get(source_lang, source_lang)})")
+            if self.ast:
+                print(f"target lang: {target_lang} ({self.lang_names.get(target_lang, target_lang)})")
+            print(f"dataset size: {len(self.data)}")
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        audio_array = data["audio"]["array"]
+
+        if self.ast:
+            answer_text = data["translation"]
+        else:
+            answer_text = data["transcription"]
+        
+        return self.prepare_model_inputs(
+            audio_array,
+            self.instruction.format(self.target_lang_name),
+            answer_text
+        )
+
+def pad_sequence(sequences, padding_side='left', padding_value=0):
+    """
+    Pad a list of sequences to the same length.
+    sequences: list of tensors in [seq_len, *] shape
+    """
+    assert padding_side in ['right', 'left']
+    max_size = sequences[0].size()
+    trailing_dims = max_size[1:]
+    max_len = max(len(seq) for seq in sequences)
+    batch_size = len(sequences)
+    output = sequences[0].new_full((batch_size, max_len) + trailing_dims, padding_value)
+    for i, seq in enumerate(sequences):
+        length = seq.size(0)
+        if padding_side == 'right':
+            output.data[i, :length] = seq
+        else:
+            output.data[i, -length:] = seq
+    return output
+
+def cat_with_pad(tensors, dim, padding_value=0):
+    """
+    cat along dim, while pad to max for all other dims
+    """
+    ndim = tensors[0].dim()
+    assert all(
+        t.dim() == ndim for t in tensors[1:]
+    ), 'All tensors must have the same number of dimensions'
+
+    out_size = [max(t.shape[i] for t in tensors) for i in range(ndim)]
+    out_size[dim] = sum(t.shape[dim] for t in tensors)
+    output = tensors[0].new_full(out_size, padding_value)
+
+    index = 0
+    for t in tensors:
+        # Create a slice list where every dimension except dim is full slice
+        slices = [slice(0, t.shape[d]) for d in range(ndim)]
+        # Update only the concat dimension slice
+        slices[dim] = slice(index, index + t.shape[dim])
+
+        output[slices] = t
+        index += t.shape[dim]
+
+    return output
+
+def covost_collate_fn(batch):
+    input_ids_list = []
+    input_audio_embeds_list = []
+    audio_embed_sizes_list = []
+    audio_attention_mask_list = []
+    input_modes_list = []
+    answer_list = []
+    for inputs in batch:
+        input_ids_list.append(inputs['input_ids'][0])
+        input_audio_embeds_list.append(inputs['input_audio_embeds'])
+        audio_embed_sizes_list.append(inputs['audio_embed_sizes'])
+        audio_attention_mask_list.append(
+            inputs['input_audio_embeds'].new_full((inputs['input_audio_embeds'].size(1),), True, dtype=torch.bool)
+        )
+        input_modes_list.append(inputs['input_modes'])
+        answer_list.append(inputs['answer'])
+
+    try:
+        input_ids = pad_sequence(input_ids_list, padding_side='left', padding_value=0)
+        audio_attention_mask = (
+            pad_sequence(audio_attention_mask_list, padding_side='right', padding_value=False)
+            if len(audio_attention_mask_list) > 1
+            else None
+        )
+    except Exception as e:
+        print(e)
+        print(input_ids_list)
+        print(audio_attention_mask)
+        raise
+    attention_mask = (input_ids != 0).long()
+    input_audio_embeds = cat_with_pad(input_audio_embeds_list, dim=0)
+    audio_embed_sizes = torch.cat(audio_embed_sizes_list)
+    input_modes = torch.cat(input_modes_list)
+
+    return BatchFeature(
+        {
+            'input_ids': input_ids,
+            'attention_mask': attention_mask,
+            'input_audio_embeds': input_audio_embeds,
+            'audio_embed_sizes': audio_embed_sizes,
+            'audio_attention_mask': audio_attention_mask,
+            'input_modes': input_modes,
+            'answer': answer_list,
+        }
+    )
+
+def save_results(results, dataset_name, task, source_lang, target_lang=None, sample_idx=None):
+    filename = f"{task}_{dataset_name}_{source_lang}"
+    if target_lang:
+        filename += f"_to_{target_lang}"
+    if sample_idx is not None:
+        filename += f"_sample_{sample_idx}"
+    
+    filepath = os.path.join(results_dir, f"{filename}.json")
+    
+    results["timestamp"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    with open(filepath, 'w', encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=2)
+    
+    return filepath
+
+def evaluate_task(dataset, source_lang, target_lang, num_samples=-1, batch_size = 4, is_asr=True):
+    task_type = "asr" if is_asr else "translation"
+    eval_lang = source_lang if is_asr else target_lang
+    if eval_lang in normalizer:
+        eval_normalizer = normalizer[eval_lang]
+    else:
+        eval_normalizer = normalizer['other']
+    sample_results = []
+    
+    if num_samples > 0 and num_samples < len(dataset):
+        indices = np.random.choice(len(dataset), num_samples, replace=False)
+        dataset = dataset.select(indices)
+    
+    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False, collate_fn=covost_collate_fn)
+        
+    evaluated_samples = {} 
+    
+    for batch_idx, batch in enumerate(tqdm(dataloader)):
+        batch_references = batch.pop("answer")
+
+        if torch.cuda.is_available():
+            try:
+                batch = {k: v.to("cuda") for k, v in batch.items()}
+            except:
+                print('error')
+                break
+        
+        with torch.inference_mode():
+            generate_ids = model.generate(**batch, 
+            max_new_tokens=256,
+            #temperature = 1.0, top_p = 0.95, top_k = 64, do_sample=True
+            )
+            
+            input_lengths = batch['input_ids'].shape[1]
+            generate_ids = generate_ids[:, input_lengths:]
+        
+            batch_predictions = processor.batch_decode(
+                generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
+            )
+        
+        for i, (reference, prediction) in enumerate(zip(batch_references, batch_predictions)):
+            idx = batch_idx * batch_size + i
+            sample_result = {
+                "id": idx,
+                "reference": reference,
+                "prediction": converter.convert(prediction)
+            }
+            sample_results.append(sample_result)
+
+        if (batch_idx + 1) % 10 == 0:
+            temp_results = []
+            
+            for item in sample_results:
+                sample_id = item["id"]
+                
+                if sample_id in evaluated_samples:
+                    temp_item = item.copy()
+                    temp_item.update(evaluated_samples[sample_id])
+                    temp_results.append(temp_item)
+                else:
+                    temp_item = item.copy()
+                    try:
+                        ref = eval_normalizer(item["reference"])
+                        pred = eval_normalizer(item["prediction"])
+
+                        # BLEU, WER/CER
+                        utt_bleu = sacrebleu.sentence_bleu(pred, [ref]).score
+                        utt_cer = round(cer(re.sub(r"\s+", "", ref), re.sub(r"\s+", "", pred)) * 100, 2)
+                        utt_wer = round(wer(ref, pred) * 100, 2)
+
+                        metrics = {
+                            "bleu": utt_bleu,
+                            "cer": min(100,utt_cer),
+                            "wer": utt_wer
+                        }
+                        
+                        evaluated_samples[sample_id] = metrics
+                        temp_item.update(metrics)
+                    except Exception as e:
+                        print(f"Error evaluating sample {sample_id}: {e}")
+                        metrics = {
+                            "bleu": 0,
+                            "cer": 100,
+                            "wer": 100,
+                            "error": str(e)
+                        }
+                        evaluated_samples[sample_id] = metrics
+                        temp_item.update(metrics)
+                
+                    temp_results.append(temp_item)
+
+            partial_results = {
+                "task": task_type,
+                "source_lang": source_lang,
+                "target_lang": target_lang,
+                "num_samples": len(temp_results),
+                "sample_results": temp_results
+            }
+            save_results(partial_results, dataset.name, task_type, source_lang, target_lang)
+
+    for item in sample_results:
+        ref = eval_normalizer(item["reference"])
+        pred = eval_normalizer(item["prediction"])
+
+        utt_bleu = sacrebleu.sentence_bleu(pred, [ref]).score
+        utt_cer = round(cer(re.sub(r"\s+", "", ref), re.sub(r"\s+", "", pred)) * 100, 2)
+        utt_wer = round(wer(ref, pred) * 100, 2)
+
+        item.update({
+            "bleu": utt_bleu,
+            "cer": min(100,utt_cer),
+            "wer": utt_wer
+        })
+
+    avg_bleu = sum(item["bleu"] for item in sample_results) / len(sample_results)
+    avg_cer = sum(item["cer"] for item in sample_results) / len(sample_results)
+    avg_wer = sum(item["wer"] for item in sample_results) / len(sample_results)
+    
+    results = {
+        "dataset": dataset.name,
+        "task": task_type,
+        "source_lang": source_lang,
+        "target_lang": target_lang,
+        "num_samples": len(sample_results),
+        "metrics": {
+            "bleu": avg_bleu,
+            "cer": avg_cer,
+            "wer": avg_wer
+        },
+        "sample_results": sample_results
+    }
+    
+    save_results(results, dataset.name, task_type, source_lang, target_lang)
+    return results
+
+
+if __name__ == "__main__":
+
+    source_languages = [
+        ("en_us", "English"),
+    ]
+    
+    target_languages = [
+        ("zh-TW", "zh-TW"),
+    ]
+
+    num_samples = -1
+    batch_size = 32
+
+    for source_lang, target_lang in zip(source_languages, target_languages):
+        print(f"\n===== {source_lang[0]} ASR =====")
+        
+        split = "test"
+
+        datasets = []
+
+        
+        
+        commonvoice_speech_tw = CommonVoiceDataset(
+            processor=processor,
+            source_lang="zh-TW",
+            split=split
+        )
+        datasets.append(commonvoice_speech_tw)
+        fleurs = FleursDataset(
+            processor=processor,
+            split=split,
+            source_lang="en_us",  # English
+            mode="asr"
+        )
+        datasets.append(fleurs)
+
+        # Libri Speech Clean ASR mode (English -> English text)
+        # libri_speech_clean = LibriSpeechDataset(
+        #     processor=processor,
+        #     subset="clean",
+        #     split=split
+        # )
+        # datasets.append(libri_speech_clean)
+
+        # # Libri Speech Other ASR mode (English -> English text)
+        # libri_speech_other = LibriSpeechDataset(
+        #     processor=processor,
+        #     subset="other",
+        #     split=split
+        # )
+        # datasets.append(libri_speech_other)
+
+        # Fleurs ASR mode (English -> English text)
+        
+
+        for dataset in datasets:
+            # ASR
+            asr_results = evaluate_task(dataset, source_lang[0], target_lang[0], num_samples, batch_size=batch_size, is_asr = True)
+
+            print(f"\n=== {asr_results.get('dataset', 'Dataset')} | {source_lang[0]} ASR===")
+            print(f"BLEU: {asr_results.get('metrics', {}).get('bleu', 'N/A')}")
+            print(f"WER: {asr_results.get('metrics', {}).get('wer', 'N/A')}")
+            print(f"CER: {asr_results.get('metrics', {}).get('cer', 'N/A')}")

cpp/gemma_v1/eval_multiturn.py

@@ -0,0 +1,211 @@
+from io import BytesIO
+from urllib.request import urlopen
+import soundfile
+import torch
+from datasets import load_dataset, Audio
+import numpy as np
+from transformers import AutoModel, AutoProcessor, BatchFeature
+from tqdm import tqdm
+import json
+import os
+import time
+from datetime import datetime
+from whisper_normalizer.english import EnglishTextNormalizer
+from whisper_normalizer.basic import BasicTextNormalizer
+import sacrebleu
+from jiwer import cer, wer
+from torch.utils.data import Dataset, DataLoader
+import soundfile as sf
+import re
+from pathlib import Path
+import opencc
+from ASRDataset import *
+
+converter = opencc.OpenCC('s2tw.json')
+normalizer = {
+    "en_us" : EnglishTextNormalizer(),
+    "other" : BasicTextNormalizer()
+}
+
+model_id = "/mnt/jeff/gemma_test"
+revision = "main" #"v1.0"
+
+model = AutoModel.from_pretrained(
+    model_id, device_map="cuda", revision = revision, trust_remote_code=True
+).eval()
+
+processor = AutoProcessor.from_pretrained(
+    model_id, revision = revision, trust_remote_code=True
+)
+
+results_dir = f"evaluation_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+os.makedirs(results_dir, exist_ok=True)
+
+
+INSTRUCTION = {
+    "ast": "Translate the audio to {0}.",
+    "asr": "Transcribe the audio clip into text.",
+}
+
+
+
+def save_results(results, dataset_name, task, source_lang, target_lang=None, sample_idx=None):
+    filename = f"{task}_{dataset_name}_{source_lang}"
+    if target_lang:
+        filename += f"_to_{target_lang}"
+    if sample_idx is not None:
+        filename += f"_sample_{sample_idx}"
+    
+    filepath = os.path.join(results_dir, f"{filename}.json")
+    
+    results["timestamp"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    with open(filepath, 'w', encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=2)
+    
+    return filepath
+
+def evaluate_task(dataset):
+    sample_results = []
+    
+    
+    dataloader = DataLoader(dataset, batch_size=1, shuffle=False, collate_fn=covost_collate_fn)
+        
+    evaluated_samples = {} 
+    
+    for batch_idx, batch in enumerate(tqdm(dataloader)):
+
+        if torch.cuda.is_available():
+            try:
+                batch = {k: v.to("cuda") for k, v in batch.items()}
+            except:
+                print('error')
+                break
+        
+        with torch.inference_mode():
+            generate_ids = model.generate(**batch, 
+            max_new_tokens=256,
+            #temperature = 1.0, top_p = 0.95, top_k = 64, do_sample=True
+            )
+            
+            input_lengths = batch['input_ids'].shape[1]
+            generate_ids = generate_ids[:, input_lengths:]
+        
+            batch_predictions = processor.batch_decode(
+                generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
+            )
+            input_lengths = batch['input_ids'].shape[1]
+            label_ids = generate_ids[:, input_lengths:]
+            batch_references = processor.batch_decode(
+                label_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
+            )
+        
+        for i, (reference, prediction) in enumerate(zip(batch_references, batch_predictions)):
+            idx = batch_idx + i
+            sample_result = {
+                "id": idx,
+                "reference": reference,
+                "prediction": converter.convert(prediction)
+            }
+            sample_results.append(sample_result)
+
+        if (batch_idx + 1) % 10 == 0:
+            temp_results = []
+            
+            for item in sample_results:
+                sample_id = item["id"]
+                
+                if sample_id in evaluated_samples:
+                    temp_item = item.copy()
+                    temp_item.update(evaluated_samples[sample_id])
+                    temp_results.append(temp_item)
+                else:
+                    temp_item = item.copy()
+                    try:
+                        ref = eval_normalizer(item["reference"])
+                        pred = eval_normalizer(item["prediction"])
+
+                        # BLEU, WER/CER
+                        utt_bleu = sacrebleu.sentence_bleu(pred, [ref]).score
+                        utt_cer = round(cer(re.sub(r"\s+", "", ref), re.sub(r"\s+", "", pred)) * 100, 2)
+                        utt_wer = round(wer(ref, pred) * 100, 2)
+
+                        metrics = {
+                            "bleu": utt_bleu,
+                            "cer": min(100,utt_cer),
+                            "wer": utt_wer
+                        }
+                        
+                        evaluated_samples[sample_id] = metrics
+                        temp_item.update(metrics)
+                    except Exception as e:
+                        print(f"Error evaluating sample {sample_id}: {e}")
+                        metrics = {
+                            "bleu": 0,
+                            "cer": 100,
+                            "wer": 100,
+                            "error": str(e)
+                        }
+                        evaluated_samples[sample_id] = metrics
+                        temp_item.update(metrics)
+                
+                    temp_results.append(temp_item)
+
+            partial_results = {
+                "task": task_type,
+                "source_lang": source_lang,
+                "target_lang": target_lang,
+                "num_samples": len(temp_results),
+                "sample_results": temp_results
+            }
+            save_results(partial_results, dataset.name, task_type, source_lang, target_lang)
+
+    for item in sample_results:
+        ref = eval_normalizer(item["reference"])
+        pred = eval_normalizer(item["prediction"])
+
+        utt_bleu = sacrebleu.sentence_bleu(pred, [ref]).score
+        utt_cer = round(cer(re.sub(r"\s+", "", ref), re.sub(r"\s+", "", pred)) * 100, 2)
+        utt_wer = round(wer(ref, pred) * 100, 2)
+
+        item.update({
+            "bleu": utt_bleu,
+            "cer": min(100,utt_cer),
+            "wer": utt_wer
+        })
+
+    avg_bleu = sum(item["bleu"] for item in sample_results) / len(sample_results)
+    avg_cer = sum(item["cer"] for item in sample_results) / len(sample_results)
+    avg_wer = sum(item["wer"] for item in sample_results) / len(sample_results)
+    
+    results = {
+        "dataset": dataset.name,
+        "task": task_type,
+        "source_lang": source_lang,
+        "target_lang": target_lang,
+        "num_samples": len(sample_results),
+        "metrics": {
+            "bleu": avg_bleu,
+            "cer": avg_cer,
+            "wer": avg_wer
+        },
+        "sample_results": sample_results
+    }
+    
+    save_results(results, dataset.name, task_type, source_lang, target_lang)
+    return results
+
+
+if __name__ == "__main__":
+
+    datasets = []
+    pickup_dataset = MultiturnAudioDataset(split='eval',processor=processor,json_path='/mnt/jeff/InCar/data/multiturn_data/pickup_processed.json')
+    datasets.append(pickup_dataset)
+    for dataset in datasets:
+        # ASR
+        asr_results = evaluate_task(dataset)
+
+        print(f"\n=== {asr_results.get('dataset', 'Dataset')}")
+        print(f"BLEU: {asr_results.get('metrics', {}).get('bleu', 'N/A')}")
+        print(f"WER: {asr_results.get('metrics', {}).get('wer', 'N/A')}")
+        print(f"CER: {asr_results.get('metrics', {}).get('cer', 'N/A')}")

cpp/gemma_v1/merge_lora.ipynb

@@ -0,0 +1,119 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from safetensors import safe_open\n",
+    "\n",
+    "lora = {}\n",
+    "with safe_open(\"/data2/bjh/diffusion-pipe/cosmos_test/20250327_02-37-25/epoch5/adapter_model.safetensors\", framework=\"pt\", device='cpu') as f:\n",
+    "    for k in f.keys():\n",
+    "        lora[k] = f.get_tensor(k)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tensors = {}\n",
+    "with safe_open(\"/data2/bjh/ComfyUI/models/diffusion_models/Cosmos-1_0-Diffusion-14B-Text2World.safetensors\", framework=\"pt\", device='cpu') as f:\n",
+    "    for k in f.keys():\n",
+    "        tensors[k] = f.get_tensor(k)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1152"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(lora)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "name_lis = []\n",
+    "for k in lora:\n",
+    "    a = k.split('.')[1:][:-2]\n",
+    "    name = '.'.join(a)\n",
+    "    name_lis.append(name)\n",
+    "name_lis=set(name_lis)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "new_dic = {}\n",
+    "for k in tensors:\n",
+    "    name='.'.join(k.split('.')[1:][:-1])\n",
+    "    if name in name_lis:\n",
+    "        a,b = lora['diffusion_model.'+name+'.lora_A.weight'],lora['diffusion_model.'+name+'.lora_B.weight']\n",
+    "        new_dic[k]=tensors[k]+torch.matmul(b,a)\n",
+    "    else:\n",
+    "        new_dic[k]=tensors[k]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from safetensors.torch import save_file\n",
+    "save_file(new_dic,'test.safetensors')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dp",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

cpp/gemma_v1/model-00001-of-00003.safetensors

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

cpp/gemma_v1/model-00002-of-00003.safetensors

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

cpp/gemma_v1/model-00003-of-00003.safetensors

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

cpp/gemma_v1/modeling_gemma3omni.py

@@ -0,0 +1,668 @@
+import copy
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from transformers.activations import ACT2FN
+from transformers.cache_utils import Cache, HybridCache, StaticCache
+from transformers.generation import GenerationMixin
+from transformers.modeling_flash_attention_utils import FlashAttentionKwargs
+from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast, ModelOutput
+from transformers.modeling_rope_utils import ROPE_INIT_FUNCTIONS
+from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from transformers.processing_utils import Unpack
+from transformers.utils import (
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    is_torchdynamo_compiling,
+    logging,
+    replace_return_docstrings,
+)
+from transformers.utils.deprecation import deprecate_kwarg
+from transformers import AutoModel, AutoModelForCausalLM
+
+from transformers.models.gemma3.modeling_gemma3 import Gemma3CausalLMOutputWithPast, Gemma3PreTrainedModel, Gemma3MultiModalProjector
+
+from transformers import AutoConfig, AutoModelForCausalLM
+
+from .configuration_gemma3omni import Gemma3OmniConfig
+from .speech_conformer_encoder import ConformerEncoder
+from enum import Enum
+class InputMode(Enum):
+    LANGUAGE = 0
+    VISION = 1
+    SPEECH = 2
+    VISION_SPEECH = 3
+logger = logging.get_logger(__name__)
+_CONFIG_FOR_DOC = "Gemma3OmniConfig"
+
+@dataclass
+class Gemma3OmniCausalLMOutputWithPast(Gemma3CausalLMOutputWithPast): 
+    """
+    Multimodal version of `Gemma3CausalLMOutputWithPast`.
+    Adds audio-specific hidden states.
+
+    Args:
+        audio_hidden_states (`torch.FloatTensor`, *optional*):
+            A `torch.FloatTensor` of size `(batch_size, sequence_length, hidden_size)`.
+            Audio hidden states produced by the audio encoder.
+    """
+    audio_hidden_states: Optional[torch.FloatTensor] = None
+
+
+GEMMA3_START_DOCSTRING = r"""
+    This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+    library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+    etc.)
+
+    This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+    Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+    and behavior.
+
+    Parameters:
+        config ([`Gemma3Config`]):
+            Model configuration class with all the parameters of the model. Initializing with a config file does not
+            load the weights associated with the model, only the configuration. Check out the
+            [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+
+
+GEMMA3_INPUTS_DOCSTRING = r"""
+    Args:
+        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+            Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
+            it.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are input IDs?](../glossary#input-ids)
+        attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+
+            [What are attention masks?](../glossary#attention-mask)
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            If `past_key_values` is used, optionally only the last `input_ids` have to be input (see
+            `past_key_values`).
+
+            If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
+            and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more
+            information on the default strategy.
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+        position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
+            config.n_positions - 1]`.
+
+            [What are position IDs?](../glossary#position-ids)
+        past_key_values (`Cache` or `tuple(tuple(torch.FloatTensor))`, *optional*):
+            Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
+            blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values`
+            returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.
+
+            Two formats are allowed:
+            - a [`~cache_utils.Cache`] instance, see our
+            [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache);
+            - Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of
+            shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`). This is also known as the legacy
+            cache format.
+
+            The model will output the same cache format that is fed as input. If no `past_key_values` are passed, the
+            legacy cache format will be returned.
+
+            If `past_key_values` are used, the user can optionally input only the last `input_ids` (those that don't
+            have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `input_ids`
+            of shape `(batch_size, sequence_length)`.
+        inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+            Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
+            is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
+            model's internal embedding lookup matrix.
+        use_cache (`bool`, *optional*):
+            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+            `past_key_values`).
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+        cache_position (`torch.LongTensor` of shape `(sequence_length)`, *optional*):
+            Indices depicting the position of the input sequence tokens in the sequence. Contrarily to `position_ids`,
+            this tensor is not affected by padding. It is used to update the cache in the correct position and to infer
+            the complete sequence length.
+"""
+
+@add_start_docstrings(
+    "The bare Gemma3 Model outputting raw hidden-states without any specific head on top.",
+    GEMMA3_START_DOCSTRING,
+)
+class Gemma3OmniPreTrainedModel(Gemma3PreTrainedModel):
+    config_class = Gemma3OmniConfig
+
+@add_start_docstrings(
+    """The GEMMA3 model which consists of a vision backbone and a language model.""",
+    GEMMA3_START_DOCSTRING,
+)
+class Gemma3OmniForConditionalGeneration(Gemma3OmniPreTrainedModel, GenerationMixin):
+    def __init__(self, config: Gemma3OmniConfig):
+        super().__init__(config)
+        self.vision_tower = AutoModel.from_config(config=config.vision_config)
+        audio_config = config.audio_config.to_diff_dict()
+        for item in ['transformers_version', 'model_type', 'torch_dtype']:
+            if item in audio_config:
+                audio_config.pop(item)
+        self.audio_tower = ConformerEncoder(**audio_config)
+        self.audio_tower.post_init({})
+        self.audio_tower = self.audio_tower.to(dtype=self.dtype)
+        self.audio_projector = nn.Sequential(
+            nn.Linear(in_features=config.audio_config.attention_dim, out_features=config.text_config.hidden_size, bias=True),
+            nn.GELU(approximate='none'),
+            nn.Linear(in_features=config.text_config.hidden_size, out_features=config.text_config.hidden_size, bias=True)
+        ).to(dtype=self.dtype)
+
+        self.multi_modal_projector = Gemma3MultiModalProjector(config)
+        self.vocab_size = config.text_config.vocab_size
+
+        language_model = AutoModelForCausalLM.from_config(config=config.text_config)
+
+        if language_model._tied_weights_keys is not None:
+            self._tied_weights_keys = [f"language_model.{k}" for k in language_model._tied_weights_keys]
+        self.language_model = language_model
+
+        self.pad_token_id = self.config.pad_token_id if self.config.pad_token_id is not None else -1
+        self.init_lora()
+        self.post_init()
+        
+        
+    def init_lora(self):
+        from peft import LoraConfig, get_peft_model
+        import warnings
+        print('######################## speech lora #############')
+        speech_lora_config = LoraConfig(
+            r=self.config.speech_lora['r'],
+            lora_alpha=self.config.speech_lora['lora_alpha'],
+            target_modules=self.config.speech_lora['layer'],
+            use_rslora=self.config.speech_lora['use_rslora'],
+            lora_dropout=self.config.speech_lora['dp'],
+            task_type="CAUSAL_LM",
+        )
+        self.language_model.model = get_peft_model(self.language_model.model, speech_lora_config, adapter_name="speech")
+        print('######################## text lora #############')
+        text_lora_config = LoraConfig(
+            r=self.config.text_lora['r'],
+            lora_alpha=self.config.text_lora['lora_alpha'],
+            target_modules=self.config.text_lora['layer'],
+            use_rslora=self.config.text_lora['use_rslora'],
+            lora_dropout=self.config.text_lora['dp'],
+            task_type="CAUSAL_LM",
+        )
+        self.language_model.model.base_model.active_adapter.append("text")
+        self.language_model.model.add_adapter("text", text_lora_config)
+        
+    def set_lora_adapter(self, adapter_name) -> None:
+        from peft.tuners.lora.layer import LoraLayer
+        for module in self.modules():
+            if isinstance(module, LoraLayer):
+                if module.merged:
+                    warnings.warn("Adapter cannot be set when the model is merged. Unmerging the model first.")
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+                module._disable_adapters = False
+
+    def unset_lora_adapter(self) -> None:
+        # Ref: peft/tuners/tuners_utils.py - enable_adapters()
+        # Ref: peft/tuners/lora/layer.py
+        from peft.tuners.lora.layer import LoraLayer
+        for module in self.modules():
+            if isinstance(module, LoraLayer):
+                # disable grads on all adapter layers
+                # TODO weijian: may use enable_adapters() instead
+                for layer_name in module.adapter_layer_names:
+                    layer = getattr(module, layer_name)
+                    layer.requires_grad_(False)
+                module._disable_adapters = True
+
+    def get_input_embeddings(self):
+        return self.language_model.get_input_embeddings()
+
+    def set_input_embeddings(self, value):
+        self.language_model.set_input_embeddings(value)
+
+    def get_output_embeddings(self):
+        return self.language_model.get_output_embeddings()
+
+    def set_output_embeddings(self, new_embeddings):
+        self.language_model.set_output_embeddings(new_embeddings)
+
+    def set_decoder(self, decoder):
+        self.language_model.set_decoder(decoder)
+
+    def get_decoder(self):
+        return self.language_model.get_decoder()
+
+    def _update_causal_mask(
+        self,
+        attention_mask,
+        token_type_ids,
+        past_key_values,
+        cache_position,
+        input_tensor,
+        is_training: bool = False,
+    ):
+        if self.config.text_config._attn_implementation == "flash_attention_2":
+            return attention_mask
+
+        if attention_mask is not None and attention_mask.dim() == 4:
+            # In this case we assume that the mask comes already in inverted
+            # form and requires no inversion or slicing.
+            return attention_mask
+
+        using_static_cache = isinstance(past_key_values, StaticCache)
+        min_dtype = torch.finfo(self.dtype).min
+        inputs_lead_dim, sequence_length = input_tensor.shape[:2]
+        if using_static_cache:
+            target_length = past_key_values.get_max_cache_shape()
+        elif isinstance(past_key_values, HybridCache):
+            target_length = past_key_values.get_max_cache_shape()
+        else:
+            target_length = (
+                attention_mask.shape[-1]
+                if isinstance(attention_mask, torch.Tensor)
+                else cache_position[0] + sequence_length + 1
+            )
+
+        if attention_mask is not None and attention_mask.dim() == 4:
+            # In this case we assume that the mask comes already in inverted form and requires no inversion or slicing.
+            return attention_mask
+
+        causal_mask = torch.full(
+            (sequence_length, target_length), fill_value=min_dtype, dtype=self.dtype, device=cache_position.device
+        )
+
+        # Causal diagonal mask only if training, otherwise attend to the whole prefix. Training-specific attn for prefix is handled below
+        if sequence_length != 1:
+            causal_mask = torch.triu(causal_mask, diagonal=1)
+
+        causal_mask *= torch.arange(target_length, device=cache_position.device) > cache_position.reshape(-1, 1)
+        causal_mask = causal_mask[None, None, :, :].expand(inputs_lead_dim, 1, -1, -1)
+
+        # Apply bidirectional mask on images if token type ids are provided
+        if token_type_ids is not None and sequence_length != 1:
+            token_type_mask = token_type_ids.unsqueeze(1) == token_type_ids.unsqueeze(2)
+            token_type_mask[token_type_ids == 0] = False  # if text token do not change anything
+            token_type_mask = token_type_mask.unsqueeze(1).to(causal_mask.device, dtype=torch.bool)
+            causal_mask = causal_mask.clone()
+            causal_mask[:, :, :, :sequence_length] = causal_mask[:, :, :, :sequence_length].masked_fill(
+                token_type_mask, 0.0
+            )
+
+        if attention_mask is not None:
+            causal_mask = causal_mask.clone()  # copy to contiguous memory for in-place edit
+            mask_length = attention_mask.shape[-1]
+
+            # Then apply padding mask (will mask pad tokens)
+            padding_mask = causal_mask[:, :, :, :mask_length] + attention_mask[:, None, None, :].to(causal_mask.device)
+            padding_mask = padding_mask == 0
+            causal_mask[:, :, :, :mask_length] = causal_mask[:, :, :, :mask_length].masked_fill(
+                padding_mask, min_dtype
+            )
+
+        return causal_mask
+
+    def get_image_features(self, pixel_values: torch.Tensor) -> torch.Tensor:
+        """
+        Projects the last hidden state from the vision model into language model space.
+
+        Args:
+            pixel_values (`torch.FloatTensor]` of shape `(batch_size, channels, height, width)`)
+               The tensors corresponding to the input images.
+        Returns:
+            image_features (`torch.Tensor`): Image feature tensor of shape `(num_images, image_length, embed_dim)`).
+        """
+        vision_outputs = self.vision_tower(pixel_values=pixel_values).last_hidden_state
+        image_features = self.multi_modal_projector(vision_outputs)
+        return image_features
+        
+    def get_audio_features(self, input_audio_embeds: torch.FloatTensor, audio_attention_mask: torch.FloatTensor, audio_embed_sizes: torch.FloatTensor):
+        """
+        Projects the last hidden state from the audio model into language model space.
+        
+        Args:
+            audio_inputs (`torch.FloatTensor]` of shape `(batch_size, sequence_length, feature_dim)`)
+                The tensors corresponding to the input audio features.
+                
+        Returns:
+            audio_features (`torch.Tensor`): Audio feature tensor of shape `(batch_size, audio_length, embed_dim)`).
+        """
+        audio_features, masks = self.audio_tower(input_audio_embeds, audio_attention_mask)
+        audio_outputs = self.audio_projector(audio_features)
+        return audio_outputs
+
+    @deprecate_kwarg("num_logits_to_keep", version="4.50", new_name="logits_to_keep")
+    @add_start_docstrings_to_model_forward(GEMMA3_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=Gemma3OmniCausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        input_audio_embeds: torch.FloatTensor = None,
+        audio_embed_sizes: torch.FloatTensor = None,
+        audio_attention_mask: torch.FloatTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        input_modes: torch.LongTensor = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[Union[List[torch.FloatTensor], Cache]] = None,
+        token_type_ids: Optional[torch.LongTensor] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        logits_to_keep: Union[int, torch.Tensor] = 0,
+        **lm_kwargs,
+    ) -> Union[Tuple, Gemma3OmniCausalLMOutputWithPast]:
+        r"""
+            labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+                config.text_config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+                (masked), the loss is only computed for the tokens with labels in `[0, ..., config.text_config.vocab_size]`.
+
+            logits_to_keep (`int` or `torch.Tensor`, *optional*):
+                If an `int`, compute logits for the last `logits_to_keep` tokens. If `0`, calculate logits for all
+                `input_ids` (special case). Only last token logits are needed for generation, and calculating them only for that
+                token can save memory, which becomes pretty significant for long sequences or large vocabulary size.
+                If a `torch.Tensor`, must be 1D corresponding to the indices to keep in the sequence length dimension.
+                This is useful when using packed tensor format (single dimension for batch and sequence length).
+
+        Returns:
+
+        Example:
+
+        ```python
+        >>> from PIL import Image
+        >>> import requests
+        >>> from transformers import AutoProcessor, Gemma3ForConditionalGeneration
+
+        >>> model = Gemma3ForConditionalGeneration.from_pretrained("google/gemma-3-4b-it")
+        >>> processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+
+        >>> messages = [
+        ...     {
+        ...         "role": "system",
+        ...         "content": [
+        ...             {"type": "text", "text": "You are a helpful assistant."}
+        ...         ]
+        ...     },
+        ...     {
+        ...         "role": "user", "content": [
+        ...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
+        ...             {"type": "text", "text": "Where is the cat standing?"},
+        ...         ]
+        ...     },
+        ... ]
+
+        >>> inputs = processor.apply_chat_template(
+        ...     messages,
+        ...     tokenizer=True,
+        ...     return_dict=True,
+        ...     return_tensors="pt",
+        ...     add_generation_prompt=True
+        ... )
+        >>> # Generate
+        >>> generate_ids = model.generate(**inputs)
+        >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+        "user\nYou are a helpful assistant.\n\n\n\n\n\nWhere is the cat standing?\nmodel\nBased on the image, the cat is standing in a snowy area, likely outdoors. It appears to"
+        ```
+        """
+
+        if (input_ids is None) ^ (inputs_embeds is not None):
+            raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if isinstance(input_modes, torch.Tensor):
+            # len(input_mode) == num_beams in beam search, and all elements of input_mode should have the same value
+            input_modes = input_modes.unique()
+            if len(input_modes) != 1:
+                raise ValueError("Elements of input_modes should have the same value")
+
+        input_mode = InputMode(input_modes.item())
+
+        if input_mode in [InputMode.VISION_SPEECH, InputMode.VISION]:
+            self.unset_lora_adapter()
+            #self.set_lora_adapter('vision')
+            #audio_projection_mode = 'vision'
+        elif input_mode == InputMode.SPEECH:
+            self.unset_lora_adapter()
+            self.set_lora_adapter('speech')
+            #audio_projection_mode = 'speech'
+        elif input_mode == InputMode.LANGUAGE:
+            self.unset_lora_adapter()
+            self.set_lora_adapter('text')
+            
+            #audio_projection_mode = 'speech'
+        else:
+            raise ValueError(f"Invalid input_mode: {input_mode}")
+
+        is_training = token_type_ids is not None and labels is not None
+
+        # Replace image id woth PAD if the image token if OOV, to avoid index-errors
+        if input_ids is not None and self.config.image_token_index >= self.vocab_size or self.config.audio_token_index >= self.vocab_size:
+            special_image_mask = input_ids == self.config.image_token_index
+            special_audio_mask = input_ids == self.config.audio_token_index
+            llm_input_ids = input_ids.clone()
+            llm_input_ids[special_image_mask] = 0
+            llm_input_ids[special_audio_mask] = 0
+        else:
+            llm_input_ids = input_ids
+
+        if inputs_embeds is None:
+            inputs_embeds = self.get_input_embeddings()(llm_input_ids)
+        inputs_embeds = inputs_embeds.to(dtype=self.dtype)
+        if cache_position is None:
+            past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+            cache_position = torch.arange(
+                past_seen_tokens, past_seen_tokens + inputs_embeds.shape[1], device=inputs_embeds.device
+            )
+
+        if position_ids is None:
+            position_ids = cache_position.unsqueeze(0) + 1  # Gemma3 positions are 1-indexed
+
+        # Merge text and images
+        if pixel_values is not None:
+            image_features = self.get_image_features(pixel_values)
+
+            if input_ids is None:
+                special_image_mask = inputs_embeds == self.get_input_embeddings()(
+                    torch.tensor(self.config.image_token_index, dtype=torch.long, device=inputs_embeds.device)
+                )
+            else:
+                special_image_mask = (input_ids == self.config.image_token_index).unsqueeze(-1)
+                special_image_mask = special_image_mask.expand_as(inputs_embeds).to(inputs_embeds.device)
+
+            if not is_torchdynamo_compiling() and inputs_embeds[special_image_mask].numel() != image_features.numel():
+                image_tokens_in_text = (special_image_mask).sum(dim=1).sum(dim=0)[0]
+                raise ValueError(
+                    f"Number of images does not match number of special image tokens in the input text. "
+                    f"Got {image_tokens_in_text} image tokens in the text but {image_features.shape[0] * image_features.shape[1]} "
+                    "tokens from image embeddings."
+                )
+            image_features = image_features.to(inputs_embeds.device, inputs_embeds.dtype)
+            inputs_embeds = inputs_embeds.masked_scatter(special_image_mask, image_features)
+
+        # Merge text and audios
+        if input_audio_embeds is not None:
+            input_audio_embeds=input_audio_embeds.to(inputs_embeds.device, inputs_embeds.dtype)
+            if audio_attention_mask is not None:
+                audio_attention_mask=audio_attention_mask.to(inputs_embeds.device, inputs_embeds.dtype)
+            audio_features = self.get_audio_features(input_audio_embeds, audio_attention_mask, audio_embed_sizes)
+            if input_ids is None:
+                special_audio_mask = inputs_embeds == self.get_input_embeddings()(
+                    torch.tensor(self.config.audio_token_index, dtype=torch.long, device=inputs_embeds.device)
+                )
+            else:
+                special_audio_mask = (input_ids == self.config.audio_token_index).unsqueeze(-1)
+                special_audio_mask = special_audio_mask.expand_as(inputs_embeds).to(inputs_embeds.device)
+            masked_audio_features = []
+            for i, size in enumerate(audio_embed_sizes):
+                masked_audio_features.append(audio_features[i, :size, :])
+            masked_audio_features = torch.cat(masked_audio_features, dim=0)
+
+            if not is_torchdynamo_compiling() and inputs_embeds[special_audio_mask].numel() != masked_audio_features.numel():
+                audio_tokens_in_text = (special_audio_mask).sum(dim=1).sum(dim=0)[0]
+                masked_audio_size = audio_embed_sizes#.sum()[0]
+                raise ValueError(
+                    f"Number of audio does not match number of special audio tokens in the input text. "
+                    f"Got {audio_tokens_in_text} audio tokens in the text but {masked_audio_size} "
+                    "tokens from audio embeddings. "
+                    f"{masked_audio_features.numel()} \n"
+                    f"{inputs_embeds[special_audio_mask].numel()} \n"
+                    f"{audio_features} \n"
+                    f"{inputs_embeds[special_audio_mask]} \n"
+                    f"{special_audio_mask} \n"
+                )
+            masked_audio_features = masked_audio_features.to(inputs_embeds.device, inputs_embeds.dtype)
+            inputs_embeds = inputs_embeds.masked_scatter(special_audio_mask, masked_audio_features)
+        # mask out pad-token-ids in labels for BC
+        if labels is not None and self.pad_token_id in labels:
+            logger.warning_once(
+                "`labels` contains `pad_token_id` which will be masked with `config.ignore_index`. "
+                "You have to mask out `pad_token_id` when preparing `labels`, this behavior will be removed in v.4.46.",
+            )
+            labels = torch.where(input_ids == self.pad_token_id, self.config.ignore_index, labels)
+
+        causal_mask = self._update_causal_mask(
+            attention_mask, token_type_ids, past_key_values, cache_position, inputs_embeds, is_training
+        )
+        outputs = self.language_model(
+            attention_mask=causal_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            cache_position=cache_position,
+            logits_to_keep=logits_to_keep,
+            **lm_kwargs,
+        )
+
+        logits = outputs.logits
+        loss = None
+        # print('#############################')
+        # print(logits)
+        if labels is not None:
+            # Upcast to float if we need to compute the loss to avoid potential precision issues
+            logits = logits.float()
+            shift_logits = logits[..., :-1, :]
+            shift_labels = labels[..., 1:]
+            if attention_mask is not None:
+                # we use the input attention mask to shift the logits and labels, because it is 2D.
+                # we also crop attn mask in case it is longer, which happens in PrefixTuning with peft
+                shift_attention_mask = attention_mask[:, -shift_logits.shape[1] :].to(logits.device)
+                shift_logits = shift_logits[shift_attention_mask.to(logits.device) != 0].contiguous()
+                shift_labels = shift_labels[shift_attention_mask.to(shift_labels.device) != 0].contiguous()
+            else:
+                shift_logits = shift_logits.contiguous()
+                shift_labels = shift_labels.contiguous()
+            # Flatten the tokens
+            loss_fct = nn.CrossEntropyLoss()
+
+            flat_logits = shift_logits.view(-1, self.config.text_config.vocab_size)
+            flat_labels = shift_labels.view(-1).to(shift_logits.device)
+            loss = loss_fct(flat_logits, flat_labels)
+            # print('flat logits',flat_logits)
+            # print(flat_labels)
+            # print(loss)
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            return (loss,) + output if loss is not None else output
+
+        return Gemma3OmniCausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+            image_hidden_states=image_features if pixel_values is not None else None,
+            audio_hidden_states=audio_features if input_audio_embeds is not None else None,
+        )
+
+    def prepare_inputs_for_generation(
+        self,
+        input_ids,
+        past_key_values=None,
+        input_modes=None,
+        inputs_embeds=None,
+        cache_position=None,
+        position_ids=None,
+        pixel_values=None,
+        input_audio_embeds=None,
+        audio_embed_sizes=None,
+        audio_attention_mask=None,
+        attention_mask=None,
+        token_type_ids=None,
+        use_cache=True,
+        logits_to_keep=None,
+        labels=None,
+        **kwargs,
+    ):
+        # Overwritten -- custom `position_ids` and `pixel_values` handling
+        model_inputs = self.language_model.prepare_inputs_for_generation(
+            input_ids,
+            past_key_values=past_key_values,
+            input_modes=input_modes,
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            cache_position=cache_position,
+            use_cache=use_cache,
+            logits_to_keep=logits_to_keep,
+            token_type_ids=token_type_ids,
+            **kwargs,
+        )
+
+        # position_ids in Gemma3 are 1-indexed
+        if model_inputs.get("position_ids") is not None:
+            model_inputs["position_ids"] += 1
+        # If we're in cached decoding stage, pixel values should be None because input ids do not contain special image token anymore
+        # Otherwise we need pixel values to be passed to model. NOTE: use_cache=False needs pixel_values always
+        if cache_position[0] == 0:
+            model_inputs["pixel_values"] = pixel_values
+            model_inputs["input_audio_embeds"] = input_audio_embeds
+            model_inputs["audio_embed_sizes"] = audio_embed_sizes
+            model_inputs["audio_attention_mask"] = audio_attention_mask
+        model_inputs["input_modes"] = input_modes
+        is_training = token_type_ids is not None and labels is not None
+        if cache_position[0] == 0 and isinstance(past_key_values, HybridCache):
+            input_tensor = inputs_embeds if inputs_embeds is not None else input_ids
+            causal_mask = self._update_causal_mask(
+                attention_mask, token_type_ids, past_key_values, cache_position, input_tensor, is_training
+            )
+            model_inputs["attention_mask"] = causal_mask
+
+        return model_inputs
+
+    def tie_weights(self):
+        return self.language_model.tie_weights()
+

cpp/gemma_v1/preprocessing_gemma3omni.py

@@ -0,0 +1,444 @@
+import re
+from typing import List, Optional, Union, Tuple
+from math import ceil
+
+import numpy as np
+import torch
+import scipy
+from torch.nn.utils.rnn import pad_sequence
+
+from enum import Enum
+
+from transformers import AutoFeatureExtractor
+from transformers.feature_extraction_utils import BatchFeature
+from transformers.feature_extraction_sequence_utils import SequenceFeatureExtractor
+from transformers.image_utils import ImageInput, make_nested_list_of_images
+from transformers.processing_utils import ImagesKwargs, ProcessingKwargs, ProcessorMixin, Unpack, AudioKwargs
+from transformers.tokenization_utils_base import PreTokenizedInput, TextInput
+from transformers.utils import to_py_obj, TensorType
+from transformers.audio_utils import AudioInput
+
+
+class Gemma3ImagesKwargs(ImagesKwargs):
+    do_pan_and_scan: Optional[bool]
+    pan_and_scan_min_crop_size: Optional[int]
+    pan_and_scan_max_num_crops: Optional[int]
+    pan_and_scan_min_ratio_to_activate: Optional[float]
+    do_convert_rgb: Optional[bool]
+
+
+class Gemma3ProcessorKwargs(ProcessingKwargs, total=False):
+    images_kwargs: Gemma3ImagesKwargs
+    _defaults = {
+        "text_kwargs": {
+            "padding": False,
+        },
+        "images_kwargs": {
+            "do_pan_and_scan": False,
+            "pan_and_scan_min_crop_size": 256,
+            "pan_and_scan_max_num_crops": 4,
+            "pan_and_scan_min_ratio_to_activate": 1.2,
+        },
+    }
+
+def speechlib_mel(sample_rate, n_fft, n_mels, fmin=None, fmax=None):
+    """Create a Mel filter-bank the same as SpeechLib FbankFC.
+
+    Args:
+        sample_rate (int): Sample rate in Hz. number > 0 [scalar]
+        n_fft (int): FFT size. int > 0 [scalar]
+        n_mel (int): Mel filter size. int > 0 [scalar]
+        fmin (float): lowest frequency (in Hz). If None use 0.0.
+            float >= 0 [scalar]
+        fmax: highest frequency (in Hz). If None use sample_rate / 2.
+            float >= 0 [scalar]
+
+    Returns
+        out (numpy.ndarray): Mel transform matrix
+            [shape=(n_mels, 1 + n_fft/2)]
+    """
+
+    bank_width = int(n_fft // 2 + 1)
+    if fmax is None:
+        fmax = sample_rate / 2
+    if fmin is None:
+        fmin = 0
+    assert fmin >= 0, "fmin cannot be negtive"
+    assert fmin < fmax <= sample_rate / 2, "fmax must be between (fmin, samplerate / 2]"
+
+    def mel(f):
+        return 1127.0 * np.log(1.0 + f / 700.0)
+
+    def bin2mel(fft_bin):
+        return 1127.0 * np.log(1.0 + fft_bin * sample_rate / (n_fft * 700.0))
+
+    def f2bin(f):
+        return int((f * n_fft / sample_rate) + 0.5)
+
+    # Spec 1: FFT bin range [f2bin(fmin) + 1, f2bin(fmax) - 1]
+    klo = f2bin(fmin) + 1
+    khi = f2bin(fmax)
+
+    khi = max(khi, klo)
+
+    # Spec 2: SpeechLib uses trianges in Mel space
+    mlo = mel(fmin)
+    mhi = mel(fmax)
+    m_centers = np.linspace(mlo, mhi, n_mels + 2)
+    ms = (mhi - mlo) / (n_mels + 1)
+
+    matrix = np.zeros((n_mels, bank_width), dtype=np.float32)
+    for m in range(0, n_mels):
+        left = m_centers[m]
+        center = m_centers[m + 1]
+        right = m_centers[m + 2]
+        for fft_bin in range(klo, khi):
+            mbin = bin2mel(fft_bin)
+            if left < mbin < right:
+                matrix[m, fft_bin] = 1.0 - abs(center - mbin) / ms
+
+    return matrix
+
+
+class Gemma3AudioFeatureExtractor(SequenceFeatureExtractor):
+    model_input_names = ["input_audio_embeds", "audio_embed_sizes", "audio_attention_mask"]
+
+    def __init__(self, audio_compression_rate=8, 
+                 audio_downsample_rate=1, 
+                 audio_feat_stride=1,
+                 feature_size = 80,
+                 sampling_rate = 16000,
+                 padding_value = 0.0,
+                 **kwargs):
+        
+        super().__init__(feature_size=feature_size, 
+                         sampling_rate=sampling_rate, 
+                         padding_value=padding_value, **kwargs)
+
+        self.compression_rate = audio_compression_rate
+        self.qformer_compression_rate = audio_downsample_rate
+        self.feat_stride = audio_feat_stride
+
+        self._eightk_method = "fillzero"
+        self._mel = speechlib_mel(self.sampling_rate, 512, self.feature_size, fmin=None, fmax=self.sampling_rate//2-self.feature_size-230).T
+
+        self._hamming400 = np.hamming(400)  # for 16k audio
+        self._hamming200 = np.hamming(200)  # for 8k audio
+
+    def duration_to_frames(self, duration):
+        """duration in s, estimated frames"""
+        frame_rate = 10
+
+        num_frames = duration * 1000 // frame_rate
+        return num_frames
+
+    def __call__(
+        self,
+        audios: List[AudioInput],
+        sampling_rate = 16000,
+        return_attention_mask=True,
+        padding="max_length",
+        return_tensors: Optional[Union[str, TensorType]] = None,
+    ):
+        # Ref: https://github.com/huggingface/transformers/blob/v4.47.0/src/transformers/models/audio_spectrogram_transformer/feature_extraction_audio_spectrogram_transformer.py#L161
+        returned_input_audio_embeds = []
+        returned_audio_embed_sizes = []
+        audio_frames_list = []
+
+        for audio_data in audios:
+            audio_embeds = self._extract_features(audio_data, sampling_rate)
+            audio_frames = len(audio_embeds) * self.feat_stride
+            audio_embed_size = self._compute_audio_embed_size(audio_frames)
+
+            returned_input_audio_embeds.append(torch.tensor(audio_embeds))
+            returned_audio_embed_sizes.append(torch.tensor(audio_embed_size).long())
+            audio_frames_list.append(audio_frames)
+
+        returned_input_audio_embeds = pad_sequence(
+            returned_input_audio_embeds, batch_first=True
+        )
+        returned_audio_embed_sizes = torch.stack(returned_audio_embed_sizes, dim=0)
+        audio_frames = torch.tensor(audio_frames_list)
+        returned_audio_attention_mask = torch.arange(0, audio_frames.max()).unsqueeze(0) < audio_frames.unsqueeze(1) if len(audios) > 1 else None
+
+        data = {
+            "input_audio_embeds": returned_input_audio_embeds,
+            "audio_embed_sizes": returned_audio_embed_sizes,
+        }
+        if returned_audio_attention_mask is not None and return_attention_mask:
+            data["audio_attention_mask"] = returned_audio_attention_mask
+
+        return BatchFeature(data=data, tensor_type=return_tensors)
+
+    def _extract_spectrogram(self, wav, fs):
+        """Extract spectrogram features from waveform.
+        Args:
+            wav (1D array): waveform of the input
+            fs (int): sampling rate of the waveform, 16000 or 8000.
+                If fs=8000, the waveform will be resampled to 16000Hz.
+        Output:
+            log_fbank (2D array): a TxD matrix of log Mel filterbank features.
+                D=80, and T is the number of frames.
+        """
+        if wav.ndim > 1:
+            wav = np.squeeze(wav)
+
+        # by default, we extract the mean if stereo
+        if len(wav.shape) == 2:
+            wav = wav.mean(1)
+
+        # Resample to 16000 or 8000 if needed
+        if fs > 16000:
+            wav = scipy.signal.resample_poly(wav, 1, fs // 16000)
+            fs = 16000
+        elif 8000 < fs < 16000:
+            wav = scipy.signal.resample_poly(wav, 1, fs // 8000)
+            fs = 8000
+        elif fs < 8000:
+            raise RuntimeError(f"Unsupported sample rate {fs}")
+
+        if fs == 8000:
+            if self._eightk_method == "resample":
+                # Input audio is 8 kHz. Convert to 16 kHz before feature
+                # extraction
+                wav = scipy.signal.resample_poly(wav, 2, 1)
+                fs = 16000
+            # Do nothing here for fillzero method
+        elif fs != 16000:
+            # Input audio is not a supported sample rate.
+            raise RuntimeError(f"Input data using an unsupported sample rate: {fs}")
+
+        preemphasis = 0.97
+
+        if fs == 8000:
+            n_fft = 256
+            win_length = 200
+            hop_length = 80
+            fft_window = self._hamming200
+        elif fs == 16000:
+            n_fft = 512
+            win_length = 400
+            hop_length = 160
+            fft_window = self._hamming400
+
+        # Spec 1: SpeechLib cut remaining sample insufficient for a hop
+        n_batch = (wav.shape[0] - win_length) // hop_length + 1
+        # Here we don't use stride_tricks since the input array may not satisfy
+        # memory layout requirement and we need writeable output
+        # Here we only use list of views before copy to desination
+        # so it is more efficient than broadcasting
+        y_frames = np.array(
+            [wav[_stride : _stride + win_length] for _stride in range(0, hop_length * n_batch, hop_length)],
+            dtype=np.float32,
+        )
+
+        # Spec 2: SpeechLib applies preemphasis within each batch
+        y_frames_prev = np.roll(y_frames, 1, axis=1)
+        y_frames_prev[:, 0] = y_frames_prev[:, 1]
+        y_frames = (y_frames - preemphasis * y_frames_prev) * 32768
+
+        S = np.fft.rfft(fft_window * y_frames, n=n_fft, axis=1).astype(np.complex64)
+
+        if fs == 8000:
+            # Need to pad the output to look like 16 kHz data but with zeros in
+            # the 4 to 8 kHz bins.
+            frames, bins = S.shape
+            padarray = np.zeros((frames, bins))
+            S = np.concatenate((S[:, 0:-1], padarray), axis=1)  # Nyquist bin gets set to zero
+
+        spec = np.abs(S).astype(np.float32)
+        return spec
+
+    def _extract_features(self, wav, fs):
+        """Extract log filterbank features from waveform.
+        Args:
+            wav (1D array): waveform of the input
+            fs (int): sampling rate of the waveform, 16000 or 8000.
+                If fs=8000, the waveform will be resampled to 16000Hz.
+        Output:
+            log_fbank (2D array): a TxD matrix of log Mel filterbank features.
+                D=80, and T is the number of frames.
+        """
+        spec = self._extract_spectrogram(wav, fs)
+        spec_power = spec**2
+
+        fbank_power = np.clip(spec_power.dot(self._mel), 1.0, None)
+        log_fbank = np.log(fbank_power).astype(np.float32)
+
+        return log_fbank
+
+    def _compute_audio_embed_size(self, audio_frames):
+        integer = audio_frames // self.compression_rate
+        remainder = audio_frames % self.compression_rate
+
+        result = integer if remainder == 0 else integer + 1
+
+        integer = result // self.qformer_compression_rate
+        remainder = result % self.qformer_compression_rate
+        result = integer if remainder == 0 else integer + 1  # qformer compression
+
+        return result
+
+class Gemma3OmniProcessor(ProcessorMixin):
+    attributes = ["image_processor", "feature_extractor", "tokenizer"]
+    valid_kwargs = ["chat_template", "image_seq_length"]
+    image_processor_class = "AutoImageProcessor"
+    feature_extractor_class = "Gemma3AudioFeatureExtractor"
+    tokenizer_class = "AutoTokenizer"
+
+    def __init__(
+        self,
+        image_processor,
+        feature_extractor,
+        tokenizer,
+        chat_template=None,
+        image_seq_length: int = 256,
+        **kwargs,
+    ):
+        self.image_seq_length = image_seq_length
+        self.image_token_id = tokenizer.image_token_id
+        self.boi_token = tokenizer.boi_token
+        self.image_token = tokenizer.image_token
+        image_tokens_expanded = "".join([tokenizer.image_token] * image_seq_length)
+        self.full_image_sequence = f"\n\n{tokenizer.boi_token}{image_tokens_expanded}{tokenizer.eoi_token}\n\n"
+
+        self.audio_token_id = tokenizer.audio_token_id
+        self.boa_token = tokenizer.boa_token
+        self.eoa_token = tokenizer.eoa_token
+        self.audio_token = tokenizer.audio_token
+        
+        super().__init__(
+            image_processor=image_processor,
+            feature_extractor=feature_extractor,
+            tokenizer=tokenizer,
+            chat_template=chat_template,
+            **kwargs,
+        )
+
+    def __call__(
+        self,
+        images: ImageInput = None,
+        text: Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None,
+        videos=None,
+        audio: List[AudioInput] = None,
+        **kwargs: Unpack[Gemma3ProcessorKwargs],
+    ) -> BatchFeature:
+        if text is None and images is None:
+            raise ValueError("Provide at least one of `text` or `images`.")
+
+        output_kwargs = self._merge_kwargs(
+            Gemma3ProcessorKwargs,
+            tokenizer_init_kwargs=self.tokenizer.init_kwargs,
+            **kwargs,
+        )
+
+        if isinstance(text, str):
+            text = [text]
+        elif not isinstance(text, list) and not isinstance(text[0], str):
+            raise ValueError("Invalid input text. Please provide a string, or a list of strings")
+
+        image_inputs = {}
+        if images is not None:
+            batched_images = make_nested_list_of_images(images)
+            image_inputs = self.image_processor(batched_images, **output_kwargs["images_kwargs"])
+
+            # Create empty text to be replaced with placeholders
+            if not text:
+                text = [" ".join([self.boi_token] * len(images)) for images in batched_images]
+
+            if len(batched_images) != len(text):
+                raise ValueError(
+                    f"Received inconsistently sized batches of images ({len(batched_images)}) and text ({len(text)})."
+                )
+
+            # Replace image tokens by the full expanded sequence
+            num_crops = to_py_obj(image_inputs.pop("num_crops"))
+            batch_num_crops = [[num_crops.pop(0) for _ in range(len(images))] for images in batched_images]
+            for batch_idx, (prompt, images, num_crops) in enumerate(zip(text, batched_images, batch_num_crops)):
+                image_indexes = [m.start() for m in re.finditer(self.boi_token, prompt)]
+
+                if len(images) != len(image_indexes):
+                    raise ValueError(
+                        f"Prompt contained {len(image_indexes)} image tokens but received {len(images)} images."
+                    )
+
+                # Insert additional image tokens for Pan-and-Scan crops
+                for num, idx in reversed(list(zip(num_crops, image_indexes))):
+                    if num:
+                        formatted_image_text = (
+                            f"Here is the original image {self.boi_token} and here are some crops to help you see better "
+                            + " ".join([self.boi_token] * num)
+                        )
+                        prompt = prompt[:idx] + formatted_image_text + prompt[idx + len(self.boi_token) :]
+                        text[batch_idx] = prompt
+
+            # Expand placeholder image tokens to the full image token sequence
+            text = [prompt.replace(self.boi_token, self.full_image_sequence) for prompt in text]
+
+        return_tensors = output_kwargs["text_kwargs"].pop("return_tensors", None)
+    
+        audio_inputs = {}
+        if audio is not None:
+            full_audio_sequences = []
+            audio_inputs = self.feature_extractor(audio)
+            def replace_tokens_sequentially(prompt, boa_token, audio_sequences):
+                parts = prompt.split(boa_token)
+                result = ""
+                for i in range(len(parts) - 1):
+                    result += parts[i]
+                    if i < len(audio_sequences):
+                        result += audio_sequences[i]
+                    else:
+                        result += boa_token
+                result += parts[-1]
+                return result
+            for i, embed_size in enumerate(audio_inputs.audio_embed_sizes):
+                audio_tokens_expanded = "".join([self.audio_token] * embed_size)
+                full_audio_sequence = f"\n\n{self.boa_token}{audio_tokens_expanded}{self.eoa_token}\n\n"
+                full_audio_sequences.append(full_audio_sequence)
+            
+            text = [replace_tokens_sequentially(prompt, self.boa_token, [audio_sequences]) for (prompt, audio_sequences) in zip(text, full_audio_sequences)]
+            #text = [prompt.replace(self.boa_token, audio_sequences) for (prompt, audio_sequences) in zip(text, full_audio_sequences)]
+
+        text_inputs = self.tokenizer(text=text, **output_kwargs["text_kwargs"], return_tensors="np")
+
+        # Add token type ids manually, as tokenizer can't do arbitrary position token types
+        array_ids = text_inputs["input_ids"]
+        mm_token_type_ids = np.zeros_like(text_inputs["input_ids"])
+        mm_token_type_ids[array_ids == self.image_token_id] = 1
+        mm_token_type_ids[array_ids == self.audio_token_id] = 2
+
+        has_vision_ids = np.any(mm_token_type_ids == 1, axis=1)
+        has_audio_ids = np.any(mm_token_type_ids == 2, axis=1)
+
+        input_modes = (has_audio_ids << 1) | has_vision_ids
+
+        text_inputs = {k: v.tolist() for k, v in text_inputs.items()}  # in case user requested list inputs
+        text_inputs["token_type_ids"] = mm_token_type_ids.tolist()
+        text_inputs["input_modes"] = input_modes.tolist()
+        
+        return BatchFeature(data={**text_inputs, **image_inputs, **audio_inputs}, tensor_type=return_tensors)
+
+    # Copied from transformers.models.clip.processing_clip.CLIPProcessor.batch_decode with CLIP->Gemma
+    def batch_decode(self, *args, **kwargs):
+        """
+        This method forwards all its arguments to GemmaTokenizerFast's [`~PreTrainedTokenizer.batch_decode`]. Please
+        refer to the docstring of this method for more information.
+        """
+        return self.tokenizer.batch_decode(*args, **kwargs)
+
+    # Copied from transformers.models.clip.processing_clip.CLIPProcessor.decode with CLIP->Gemma
+    def decode(self, *args, **kwargs):
+        """
+        This method forwards all its arguments to GemmaTokenizerFast's [`~PreTrainedTokenizer.decode`]. Please refer to
+        the docstring of this method for more information.
+        """
+        return self.tokenizer.decode(*args, **kwargs)
+
+    @property
+    def model_input_names(self):
+        tokenizer_input_names = self.tokenizer.model_input_names + ["token_type_ids"]
+        image_processor_input_names = self.image_processor.model_input_names
+        return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))
+
+AutoFeatureExtractor.register("Gemma3AudioFeatureExtractor", Gemma3AudioFeatureExtractor)

cpp/gemma_v1/preprocessor_config.json

@@ -0,0 +1,41 @@
+{
+  "audio_compression_rate": 8,
+  "audio_downsample_rate": 1,
+  "audio_feat_stride": 1,
+  "compression_rate": 8,
+  "do_convert_rgb": null,
+  "do_normalize": true,
+  "do_pan_and_scan": null,
+  "do_rescale": true,
+  "do_resize": true,
+  "feat_stride": 1,
+  "feature_extractor_type": "Gemma3AudioFeatureExtractor",
+  "feature_size": 80,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_processor_type": "Gemma3ImageProcessor",
+  "image_seq_length": 256,
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "padding_side": "right",
+  "padding_value": 0.0,
+  "pan_and_scan_max_num_crops": null,
+  "pan_and_scan_min_crop_size": null,
+  "pan_and_scan_min_ratio_to_activate": null,
+  "processor_class": "Gemma3OmniProcessor",
+  "qformer_compression_rate": 1,
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "return_attention_mask": true,
+  "sampling_rate": 16000,
+  "size": {
+    "height": 896,
+    "width": 896
+  }
+}

cpp/gemma_v1/processor_config.json

@@ -0,0 +1,7 @@
+{
+  "auto_map": {
+    "AutoProcessor": "preprocessing_gemma3omni.Gemma3OmniProcessor"
+  },
+  "image_seq_length": 256,
+  "processor_class": "Gemma3Processor"
+}

cpp/gemma_v1/special_tokens_map.json

@@ -0,0 +1,36 @@
+{
+  "audio_token": "<audio_soft_token>",
+  "boa_token": "<start_of_audio>",
+  "boi_token": "<start_of_image>",
+  "bos_token": {
+    "content": "<bos>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eoa_token": "<end_of_audio>",
+  "eoi_token": "<end_of_image>",
+  "eos_token": {
+    "content": "<eos>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "image_token": "<image_soft_token>",
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

cpp/gemma_v1/tokenizer.json

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

cpp/gemma_v1/tokenizer.model

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

cpp/gemma_v1/training.py

@@ -0,0 +1,883 @@
+import datasets
+datasets.config.DOWNLOADED_DATASETS_PATH = "/mnt/jeff/huggingface/data"
+import os
+os.environ['HF_HOME'] = '/mnt/jeff/huggingface'
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+import sacrebleu
+
+from datasets import load_dataset
+from torch.utils.data import Dataset, ConcatDataset
+from tqdm import tqdm
+from transformers import (
+    AutoProcessor,
+    AutoModel,
+    BatchFeature,
+    Trainer,
+    TrainingArguments,
+    StoppingCriteria,
+    StoppingCriteriaList,
+)
+from collections import defaultdict
+
+import soundfile as sf
+from datasets import Audio
+import random
+ANSWER_SUFFIX = "<end_of_turn>"
+_IGNORE_INDEX = -100
+class BaseAudioDataset(Dataset):
+    def __init__(self, processor, split, sampling_rate=16000, debug=False):
+        self.processor = processor
+        self.training = "train" in split or 'other' in split
+        self.debug = debug
+        self.sampling_rate = sampling_rate
+        self.name = ""
+        
+    def set_dataset_name(self, name):
+        self.name = name
+
+    @staticmethod
+    def filter_corrupted_files(data, audio_field, text_fields, dataset_name, sampling_rate=16000, debug=True):
+        original_size = len(data)
+        
+        data = data.cast_column(audio_field, Audio(decode=False))
+        
+        def identify_corrupted_files(example):
+            try:
+                sf.read(example[audio_field]["path"])
+                
+                for field in text_fields:
+                    if field in example and example[field].replace('"', '') == "":
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        data = data.filter(identify_corrupted_files, num_proc=16)
+        validated_size = len(data)
+        
+        # Audio Decoding
+        data = data.cast_column(audio_field, Audio(sampling_rate=sampling_rate, decode=True))
+        
+        if debug:
+            print(f"Dataset: {dataset_name}")
+            print(f"Original data nums: {original_size}")
+            print(f"After filtering data nums: {validated_size}")
+            print(f"Filtering ratio: {validated_size/original_size:.2%}")
+            
+        return data
+
+    @staticmethod
+    def filter_by_audio_length(data, audio_field, min_sec=2, max_sec=20, debug=True):
+        original_size = len(data)
+        
+        def filter_audio_by_length(example):
+            try:
+                audio = example[audio_field]['array']
+                channel = 1
+                if hasattr(audio, 'ndim') and audio.ndim > 1:
+                    channel = audio.ndim
+                    audio = audio.squeeze()
+                audio_length = len(audio) / example[audio_field]['sampling_rate'] / channel
+                return min_sec <= audio_length <= max_sec
+            except Exception as e:
+                if debug:
+                    print(f"Error : {str(e)[:100]}... - sample excluded")
+                return False
+        
+        data = data.filter(filter_audio_by_length, num_proc=16)
+        filtered_size = len(data)
+        
+        if debug:
+            print(f"Before Length Filtering data nums: {original_size}")
+            print(f"After Length Filtering data nums: {filtered_size}")
+            print(f"Filtering ratio: {filtered_size/original_size:.2%}")
+            
+        return data
+
+    def prepare_model_inputs(self, audio_array, instruction, answer_text):
+        user_message = {
+            'role': 'user',
+            'content': '<start_of_audio>' + instruction,
+        }
+        prompt = self.processor.tokenizer.apply_chat_template(
+            [user_message], tokenize=False, add_generation_prompt=True, add_bos=True
+        )
+        
+        inputs = self.processor(
+            text=prompt, 
+            audio=[audio_array], 
+            add_special_tokens=False, 
+            return_tensors='pt'
+        )
+        
+        answer = f"{answer_text}{ANSWER_SUFFIX}"
+        answer_ids = self.processor.tokenizer(answer, add_special_tokens=False, return_tensors='pt').input_ids
+        
+        if self.debug:
+            self.debug = False
+            task_type = 'AST' if hasattr(self, 'ast') and self.ast else 'ASR'
+            lang_info = f" - {self.lang}" if hasattr(self, 'lang') else ""
+            print(f"{task_type}{lang_info}\nPROMPT: {prompt}\nINPUT: {self.processor.decode(inputs.input_ids[0], skip_special_tokens=False)}\nANSWER: {self.processor.decode(answer_ids[0], skip_special_tokens=False)}\n")
+            print(f"INPUT_MODE: {inputs.input_modes[0].item()}")
+        
+        if self.training:
+            input_ids = torch.cat([inputs.input_ids, answer_ids], dim=1)
+            labels = torch.full_like(input_ids, _IGNORE_INDEX)
+            labels[:, -answer_ids.shape[1]:] = answer_ids
+            padding = torch.zeros((inputs.token_type_ids.shape[0], answer_ids.shape[1]))
+            token_type_ids = torch.cat([inputs.token_type_ids, padding], dim=1)
+        else:
+            input_ids = inputs.input_ids
+            labels = answer_ids
+            token_type_ids = inputs.token_type_ids
+        
+        return {
+            'input_ids': input_ids,
+            'labels': labels,
+            'token_type_ids': token_type_ids,
+            'input_audio_embeds': inputs.input_audio_embeds,
+            'audio_embed_sizes': inputs.audio_embed_sizes,
+            'input_modes': inputs.input_modes,
+        }
+
+
+# Libri Speech Dataset Class
+class LibriSpeechDataset(BaseAudioDataset):
+    def __init__(self, processor, subset, split, sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name(f"LibriSpeech_{subset}")
+        # only ASR
+        self.ast = False
+        self.lang = "en"
+        
+        # load dataset
+        self.data = load_dataset("/mnt/jeff/InCar/data/librispeech_asr",
+                            subset,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+            
+        # Instruction Setting
+        self.instruction = random.choice(INSTRUCTION["asr"])
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        # Libri Speech is only for ASR
+        answer_text = data["text"].replace('"', '')
+        
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            self.instruction,
+            answer_text
+        )
+    
+# common_voice_16_1 dataset
+class CommonVoiceDataset(BaseAudioDataset):
+    def __init__(self, processor, split, source_lang, sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name(f"CommonVoice_{source_lang}")
+        # only ASR
+        self.ast = False
+        self.lang=source_lang
+        
+        # load dataset
+        if source_lang=="zh-TW":
+            data_path = "/mnt/jeff/InCar/data/common_voice_16_1"
+        else:
+            data_path = "/mnt/jeff/InCar/data/common_voice_17_0"
+        self.data = load_dataset(data_path,
+                            source_lang,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        def prepare_dataset(batch):
+            """Function to preprocess the dataset with the .map method"""
+            transcription = batch["sentence"]
+            
+            if transcription.startswith('"') and transcription.endswith('"'):
+                # we can remove trailing quotation marks as they do not affect the transcription
+                transcription = transcription[1:-1]
+            
+            if transcription[-1] not in [".", "?", "!"]:
+                # append a full-stop to sentences that do not end in punctuation
+                transcription = transcription + "."
+            
+            batch["sentence"] = transcription
+            
+            return batch
+
+        
+        import opencc
+        converter = opencc.OpenCC('s2tw.json')
+        def To_zhTW(batch):
+            
+            transcription = converter.convert(batch["sentence"])
+            batch["sentence"] = transcription
+            
+            return batch
+        self.data = self.data.map(prepare_dataset, desc="preprocess dataset")
+        if source_lang=='zh-CN':
+            self.data = self.data.map(To_zhTW, desc="preprocess dataset To_zhTW")
+        
+        
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+
+        if source_lang == "zh-TW" and split=='train':
+            import torchaudio
+            from torchaudio import transforms
+            import copy
+            import pickle
+            import os
+            def subsample(batch):
+                batch['audio']['array']=torchaudio.functional.resample(torch.FloatTensor(batch['audio']['array']), orig_freq=batch['audio']['sampling_rate'], new_freq=16000)
+                batch['audio']['sampling_rate']=16000
+                return batch
+            def TW_data_augment_fast(batch):
+                speed_perturb_fast = transforms.SpeedPerturbation(batch['audio']['sampling_rate'], [1.1])
+                new_array_fast = speed_perturb_fast(torch.FloatTensor(batch['audio']['array']))[0]
+                batch['audio']['array'] = new_array_fast
+                return batch
+            def TW_data_augment_slow(batch):
+                speed_perturb_slow = transforms.SpeedPerturbation(batch['audio']['sampling_rate'], [0.9])
+                new_array_slow = speed_perturb_slow(torch.FloatTensor(batch['audio']['array']))[0]
+                batch['audio']['array'] = new_array_slow
+                return batch
+            # data = self.data.map(subsample, num_proc=1, desc="subsample")
+            fast_path = '/mnt/jeff/InCar/data/tw_fast.pkl'
+            if not os.path.exists(fast_path):
+                data_fast = self.data.map(TW_data_augment_fast, num_proc=1, desc="augment fast")
+                with open(fast_path,'wb') as f:
+                    pickle.dump(data_fast,f)
+            else:
+                with open(fast_path,'rb') as f:
+                    data_fast=pickle.load(f)
+            
+            slow_path = '/mnt/jeff/InCar/data/data_slow.pkl'
+            if not os.path.exists(slow_path):
+                data_slow = self.data.map(TW_data_augment_slow, num_proc=1, desc="augment slow")
+                with open(slow_path,'wb') as f:
+                    pickle.dump(data_slow,f)
+            else:
+                with open(slow_path,'rb') as f:
+                    data_slow=pickle.load(f)
+            self.data = [d for d in self.data]+[d for d in data_fast]+[d for d in data_slow]
+            
+        # Instruction Setting
+        self.instruction = random.choice(INSTRUCTION["asr"])
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        
+        answer_text = data["sentence"]
+        return self.prepare_model_inputs(
+            data["audio"]["array"],
+            self.instruction,
+            answer_text
+        )
+    
+
+# Fleurs Dataset Class
+class FleursDataset(BaseAudioDataset):
+    def __init__(self, processor, split, source_lang, target_lang=None, 
+                 mode="asr", sampling_rate=16000, debug=False):
+        super().__init__(processor, split, sampling_rate, debug)
+        
+        self.set_dataset_name("Fleurs")
+        # Mode Setting (ASR or AST)
+        if mode not in ["asr", "ast"]:
+            raise ValueError("mode must be 'asr' or 'ast'.")
+        
+        self.mode = mode
+        self.ast = (mode == "ast")
+        self.source_lang = source_lang
+        
+        # Language name mapping (expand if needed)
+        self.lang_names = {
+            'en_us': 'English', 'cmn_hans': 'Mandarin Chinese'
+        }
+        
+        # load dataset - source language dataset
+        self.data = load_dataset("/mnt/jeff/InCar/data/fleurs",
+                            source_lang,
+                            split=split,
+                            trust_remote_code=True,
+                            cache_dir=Path("/mnt/jeff/InCar/data")
+                            )
+        import opencc
+        converter = opencc.OpenCC('s2tw.json')
+        def prepare_dataset(batch):
+            transcription = converter.convert(batch["transcription"])
+            batch["transcription"] = transcription
+            
+            return batch
+        if (source_lang=="cmn_hans_cn"):
+            self.data = self.data.map(prepare_dataset, desc="preprocess dataset")
+
+        # (Optional) Audio length Filtering
+        self.data = self.filter_by_audio_length(self.data, "audio")
+        self.target_lang_name = ""
+        # When AST mode, load target language dataset.
+        if self.ast:
+            if target_lang is None:
+                raise ValueError("AST mode requires target_lang.")
+                
+            self.target_lang = target_lang
+            self.lang = f"{source_lang}_{target_lang}"
+            
+            # load dataset - target language dataset (for translation)
+            target_data = load_dataset("/mnt/jeff/InCar/data/fleurs",
+                                target_lang,
+                                split=split,
+                                trust_remote_code=True,
+                                cache_dir=Path("/mnt/jeff/InCar/data")
+                                )
+            if target_lang=="cmn_hans_cn":
+                target_data=target_data.map(prepare_dataset, desc="preprocess dataset")
+            source_dict = {item['id']: item for item in self.data}
+            target_dict = {item['id']: item for item in target_data}
+            
+            # only Common ID, add translation fields
+            common_ids = set(source_dict.keys()) & set(target_dict.keys())
+            print(f"FLEURS AST Common data filtering: {len(self.data)} -> {len(common_ids)}")
+            self.data = [
+                {**source_dict[id], 'translation': target_dict[id]['transcription']}
+                for id in common_ids
+            ]
+
+            # Instruction Setting - use target language name
+            self.target_lang_name = self.lang_names.get(target_lang, target_lang.capitalize())
+            self.instruction = random.choice(INSTRUCTION["ast"])
+        else:
+            # ASR mode
+            self.lang = source_lang
+            self.instruction = random.choice(INSTRUCTION["asr"])
+
+        if self.debug:
+            print(f"FLEURS dataset loaded: {self.mode.upper()} mode")
+            print(f"source lang: {source_lang} ({self.lang_names.get(source_lang, source_lang)})")
+            if self.ast:
+                print(f"target lang: {target_lang} ({self.lang_names.get(target_lang, target_lang)})")
+            print(f"dataset size: {len(self.data)}")
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        data = self.data[idx]
+        audio_array = data["audio"]["array"]
+
+        if self.ast:
+            answer_text = data["translation"]
+        else:
+            answer_text = data["transcription"]
+        
+        return self.prepare_model_inputs(
+            audio_array,
+            self.instruction.format(self.target_lang_name),
+            answer_text
+        )
+
+def covost_collate_fn(batch):
+    input_ids_list = []
+    labels_list = []
+    token_type_ids_list = []
+    input_audio_embeds_list = []
+    audio_embed_sizes_list = []
+    audio_attention_mask_list = []
+    input_modes_list = []
+    for inputs in batch:
+        input_ids_list.append(inputs['input_ids'][0])
+        labels_list.append(inputs['labels'][0])
+        token_type_ids_list.append(inputs['token_type_ids'][0])
+        input_audio_embeds_list.append(inputs['input_audio_embeds'])
+        audio_embed_sizes_list.append(inputs['audio_embed_sizes'])
+        audio_attention_mask_list.append(
+            inputs['input_audio_embeds'].new_full((inputs['input_audio_embeds'].size(1),), True, dtype=torch.bool)
+        )
+        input_modes_list.append(inputs['input_modes'])
+
+    try:
+        token_type_ids = pad_sequence(token_type_ids_list, padding_side='left', padding_value=0)
+        input_ids = pad_sequence(input_ids_list, padding_side='left', padding_value=0)
+        labels = pad_sequence(labels_list, padding_side='left', padding_value=0)
+        audio_attention_mask = (
+            pad_sequence(audio_attention_mask_list, padding_side='left', padding_value=False)
+            if len(audio_attention_mask_list) > 1
+            else None
+        )
+    except Exception as e:
+        print(e)
+        print(input_ids_list)
+        print(labels_list)
+        raise
+    attention_mask = (input_ids != 0).long()
+    input_audio_embeds = cat_with_pad(input_audio_embeds_list, dim=0)
+    audio_embed_sizes = torch.cat(audio_embed_sizes_list)
+    input_modes = torch.cat(input_modes_list)
+    
+    return BatchFeature(
+        {
+            'input_ids': input_ids,
+            'labels': labels,
+            'token_type_ids': token_type_ids,
+            'attention_mask': attention_mask,
+            'input_audio_embeds': input_audio_embeds,
+            'audio_embed_sizes': audio_embed_sizes,
+            'audio_attention_mask': audio_attention_mask,
+            'input_modes': input_modes,
+        }
+    )
+
+def pad_sequence(sequences, padding_side='left', padding_value=0):
+    """
+    Pad a list of sequences to the same length.
+    sequences: list of tensors in [seq_len, *] shape
+    """
+    assert padding_side in ['right', 'left']
+    max_size = sequences[0].size()
+    trailing_dims = max_size[1:]
+    max_len = max(len(seq) for seq in sequences)
+    batch_size = len(sequences)
+    output = sequences[0].new_full((batch_size, max_len) + trailing_dims, padding_value)
+    for i, seq in enumerate(sequences):
+        length = seq.size(0)
+        if padding_side == 'right':
+            output.data[i, :length] = seq
+        else:
+            output.data[i, -length:] = seq
+    return output
+
+def cat_with_pad(tensors, dim, padding_value=0):
+    """
+    cat along dim, while pad to max for all other dims
+    """
+    ndim = tensors[0].dim()
+    assert all(
+        t.dim() == ndim for t in tensors[1:]
+    ), 'All tensors must have the same number of dimensions'
+
+    out_size = [max(t.shape[i] for t in tensors) for i in range(ndim)]
+    out_size[dim] = sum(t.shape[dim] for t in tensors)
+    output = tensors[0].new_full(out_size, padding_value)
+
+    index = 0
+    for t in tensors:
+        # Create a slice list where every dimension except dim is full slice
+        slices = [slice(0, t.shape[d]) for d in range(ndim)]
+        # Update only the concat dimension slice
+        slices[dim] = slice(index, index + t.shape[dim])
+
+        output[slices] = t
+        index += t.shape[dim]
+
+    return output
+
+def count_parameters_by_module(model):
+    # dictionary for parameters number by modules
+    module_params = defaultdict(lambda: {"total": 0, "trainable": 0})
+    
+    # all params
+    total_params = 0
+    total_trainable_params = 0
+    
+    # Check Embedding Token masks
+    embedding_masks = {}
+    for name, param in model.named_parameters():
+        if 'embed_tokens.weight' in name and hasattr(param, '_backward_hooks') and param._backward_hooks:
+            # check if params has embedding_grad_mask_hook
+            for hook_id, hook_fn in param._backward_hooks.items():
+                if hook_fn.__code__.co_name == 'embedding_grad_mask_hook':
+                    # Accessing mask variables in the closure of hook functions
+                    for cell in hook_fn.__closure__ or []:
+                        if isinstance(cell.cell_contents, torch.Tensor) and cell.cell_contents.dtype == torch.bool:
+                            # check mask tensor
+                            embedding_masks[name] = ~cell.cell_contents  # True : Trainable
+                 
+    # Count params by modules
+    for name, param in model.named_parameters():
+        # extracts top module_name
+        module_name = name.split('.')[0]
+        param_count = param.numel()
+        
+        module_params[module_name]["total"] += param_count
+        total_params += param_count
+        
+        if param.requires_grad:
+            # Only count for real trainable params. (with masks)
+            if name in embedding_masks:
+                trainable_count = embedding_masks[name].sum().item()
+                module_params[module_name]["trainable"] += trainable_count
+                total_trainable_params += trainable_count
+            else:
+                module_params[module_name]["trainable"] += param_count
+                total_trainable_params += param_count
+    
+    print(f"All Params: {total_params:,}")
+    print(f"Trainable Params: {total_trainable_params:,} ({total_trainable_params/total_params*100:.2f}%)")
+    print("\nParams by Module:")
+    
+    for module_name, counts in sorted(module_params.items()):
+        trainable_percentage = counts["trainable"] / counts["total"] * 100 if counts["total"] > 0 else 0
+        total_percentage = counts["total"] / total_params * 100
+        
+        print(f"- {module_name}:")
+        print(f"  Total: {counts['total']:,} ({total_percentage:.2f}% of model)")
+        print(f"  Trainable: {counts['trainable']:,} ({trainable_percentage:.2f}% of module)")
+    
+    return module_params
+
+def create_model(model_name_or_path, revision="main", use_flash_attention = False):
+    model = AutoModel.from_pretrained(
+        model_name_or_path,
+        revision=revision,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        attn_implementation="flash_attention_2" if use_flash_attention else "eager",
+        trust_remote_code=True,
+    )
+    
+    # Set use_cache to False after model loaded
+    model.config.use_cache = False
+
+    # Freeze all parameters
+    for param in model.parameters():
+        param.requires_grad = False
+    
+    model.set_lora_adapter('speech')
+    model.to(torch.bfloat16)
+    
+    # (Optional) unfreeze audio_tower parameters
+    # for param in model.audio_tower.parameters():
+    #    param.requires_grad = True
+
+    # Only unfreeze audio_projector parameters
+    for param in model.audio_projector.parameters():
+        param.requires_grad = True
+
+    # (Optional) unfreeze audio embed_tokens
+    train_embed = True
+    if train_embed:
+        embed_tokens = model.language_model.model.model.embed_tokens
+        
+        embed_tokens.weight.requires_grad = False
+
+        # Added Speech token IDs (only this tokens be trainable)
+        trainable_token_ids = [256001, 256002]
+
+        embed_tokens.weight.requires_grad = True
+        mask = torch.ones_like(embed_tokens.weight, dtype=torch.bool)
+        mask[trainable_token_ids] = False  # Trainable Tokens are False (unfreeze), else True (freeze)
+
+        # backward hook, with gradient masking
+        def embedding_grad_mask_hook(grad):
+            return grad.masked_fill(mask, 0)
+
+        embed_tokens.weight.register_hook(embedding_grad_mask_hook)
+
+        model.language_model.model.model.embed_tokens = embed_tokens
+        
+    count_parameters_by_module(model)
+
+    return model
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false" 
+
+INSTRUCTION = {
+    "ast": [
+        "Translate the audio to {0}.",
+        "Translate the audio clip into {0}.",
+        "Based on the attached audio, generate a comprehensive {0} translation of the spoken content.",
+        "Translate the provided audio file into {0}.",
+        "Convert the audio speech to {0} text.",
+        "Write an {0} translation of the audio file.",
+        "Translate spoken words from the audio into {0}.",
+        "Create an {0} version of the audio content.",
+        "Produce an accurate {0} translation of the audio.",
+        "Extract speech from the audio and translate it to {0}.",
+        "Turn the audio into readable {0} text.",
+        "Write all spoken content from the audio in {0}.",
+        "Generate an {0} translation of the speech in the file.",
+        "Convert the recording into {0} text.",
+        "Accurately translate the audio recording to {0}.",
+        "Write down dialogue from the given audio in {0}.",
+        "Translate all speech in this audio file to {0}.",
+        "Create an accurate {0} version of the speech.",
+        "Perform a complete {0} translation of the audio."
+    ],
+    "asr": [
+        "Transcribe the audio clip into text.",
+        "Based on the attached audio, generate a comprehensive text transcription of the spoken content.",
+        "Transcribe the provided audio file into text.",
+        "Convert the audio speech to text.",
+        "Write a transcript of the audio file.",
+        "Transcribe spoken words from the audio.",
+        "Create a text version of the audio content.",
+        "Produce a verbatim transcript of the audio.",
+        "Extract and transcribe speech from the audio.",
+        "Turn the audio into readable text.",
+        "Write all spoken words from the audio.",
+        "Generate a transcript of the speech in the file.",
+        "Convert the recording into a text transcript.",
+        "Accurately transcribe the audio recording.",
+        "Write down dialogue from the given audio.",
+        "Transcribe all speech in this audio file.",
+        "Create an accurate text version of the speech.",
+        "Perform a complete transcription of the audio."
+    ],
+}
+
+ANSWER_SUFFIX = "<end_of_turn>"
+_IGNORE_INDEX = -100
+
+model_name_or_path = '/mnt/jeff/gemma-3-4b-it-omni'
+use_flash_attention = True
+
+output_dir = '../gemma_tmp7'
+batch_size = 128
+batch_size_per_gpu = 16
+learning_rate = 4.0e-5 # 1.0e-4 for fine-tuning
+wd = 0.01
+num_train_epochs = 15
+
+revision = "main" #"v1.0"
+
+processor = AutoProcessor.from_pretrained(
+    model_name_or_path,
+    revision=revision,
+    trust_remote_code=True,
+)
+
+model = create_model(
+    model_name_or_path,
+    revision=revision,
+    use_flash_attention=use_flash_attention,
+)
+
+train_datasets = []
+
+# common voice asr
+commonvoice_speech_tw2 = CommonVoiceDataset(
+    processor=processor,
+    source_lang="zh-TW",
+    split="other[:70%]"
+)
+train_datasets.append(commonvoice_speech_tw2)
+
+commonvoice_speech_cn = CommonVoiceDataset(
+    processor=processor,
+    source_lang="zh-CN",
+    split="train[:50%]"
+)
+train_datasets.append(commonvoice_speech_cn)
+
+
+commonvoice_speech_tw = CommonVoiceDataset(
+    processor=processor,
+    source_lang="zh-TW",
+    split="train"
+)
+train_datasets.append(commonvoice_speech_tw)
+
+
+
+
+# Libri Speech Clean ASR mode (English -> English text)
+libri_speech_clean = LibriSpeechDataset(
+    processor=processor,
+    subset="clean",
+    split="train.360[:50%]"
+)
+train_datasets.append(libri_speech_clean)
+
+
+# Fleurs ASR mode (English -> English text)
+en_asr_fleurs = FleursDataset(
+    processor=processor,
+    split="train",
+    source_lang="en_us",  # English
+    mode="asr"
+)
+train_datasets.append(en_asr_fleurs)
+
+
+# en_ch_ast_fleurs = FleursDataset(
+#     processor=processor,
+#     split="train",
+#     source_lang="en_us",
+#     target_lang="cmn_hans_cn",
+#     mode="ast"
+# )
+# train_datasets.append(en_ch_ast_fleurs)
+
+
+
+ch_asr_fleurs = FleursDataset(
+    processor=processor,
+    split="train",
+    source_lang="cmn_hans_cn",
+    mode="asr"
+)
+train_datasets.append(ch_asr_fleurs)
+
+
+# ch_en_ast_fleurs = FleursDataset(
+#     processor=processor,
+#     split="train",
+#     source_lang="cmn_hans_cn",
+#     target_lang="en_us",
+#     mode="ast"
+# )
+# train_datasets.append(ch_en_ast_fleurs)
+
+print("Count Num of Datasets", len(train_datasets))
+print([len(dataset) for dataset in train_datasets])
+
+# ConcatDataset
+train_dataset = ConcatDataset(train_datasets) if len(train_datasets) > 1 else train_datasets[0]
+print("Count Length of Datas", len(train_dataset))
+
+
+
+# Check GPUs
+num_gpus = torch.cuda.device_count()
+print(f'training on {num_gpus} GPUs')
+
+assert (
+    batch_size % (num_gpus * batch_size_per_gpu) == 0
+), 'Batch size must be divisible by the number of GPUs'
+gradient_accumulation_steps = batch_size // (num_gpus * batch_size_per_gpu)
+
+# hard coded training args
+dp_config = {
+    "fp16": {
+      "enabled": "auto",
+      "loss_scale": 0,
+      "loss_scale_window": 1000,
+      "initial_scale_power": 16,
+      "hysteresis": 2,
+      "min_loss_scale": 1
+  },
+   "zero_optimization": {
+       "stage": 2,
+       "allgather_partitions": True,
+       "allgather_bucket_size": 5e8,
+       "overlap_comm": False,
+       "reduce_scatter": True,
+       "reduce_bucket_size": 5e8,
+       "contiguous_gradients": True,
+       "cpu_offload": True
+   },
+
+   "train_batch_size": "auto",
+    "gradient_accumulation_steps": "auto",
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+          "lr": "auto",
+          "betas": 'auto',
+          "eps": 'auto',
+          "weight_decay": "auto"
+        }
+    },
+    "scheduler": {
+      "type": "WarmupDecayLR",
+      "params": {
+          "warmup_min_lr": "auto",
+          "warmup_max_lr": "auto",
+          "warmup_num_steps": "auto",
+          "total_num_steps": "auto"
+      }
+  },
+    "gradient_clipping": 1.0,
+    "zero_optimization": {
+        "stage": 0
+    }
+}
+training_args = TrainingArguments(
+    num_train_epochs=num_train_epochs,
+    per_device_train_batch_size=batch_size_per_gpu,
+    gradient_checkpointing=True,
+    gradient_checkpointing_kwargs={'use_reentrant': False},
+    gradient_accumulation_steps=gradient_accumulation_steps,
+    optim='adamw_torch',
+    adam_beta1=0.9,
+    adam_beta2=0.95,
+    adam_epsilon=1e-7,
+    learning_rate=learning_rate,
+    weight_decay=wd,
+    max_grad_norm=1.0,
+    lr_scheduler_type='cosine',
+    warmup_steps=50,
+    logging_steps=10,
+    output_dir=output_dir,
+    save_total_limit=10,
+    save_only_model=True,
+    bf16=True,
+    fp16=False,
+    remove_unused_columns=False,
+    report_to='none',
+    deepspeed=dp_config if num_gpus==1 else None,
+    disable_tqdm=False,
+    dataloader_num_workers=4,
+    save_strategy='steps',
+    save_steps=1000,
+    ddp_find_unused_parameters=True,
+
+)
+
+out_path = Path(training_args.output_dir)
+out_path.mkdir(parents=True, exist_ok=True)
+
+# create optimizer only for trainable params
+optimizer = torch.optim.AdamW(
+    filter(lambda p: p.requires_grad, model.parameters()),
+    lr=learning_rate,
+    weight_decay=wd,
+    betas=(0.9, 0.95),
+    eps=1e-7,
+)
+
+# Trainer Setting
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    data_collator=covost_collate_fn,
+    train_dataset=train_dataset,
+    optimizers=(optimizer, None)
+)
+
+trainer.train()
+
+
+# # 1. Save LoRA Adapter
+model.language_model.model.save_pretrained(output_dir)
+
+# # 1-1. Delete Markdown file
+# markdown_file = os.path.join(output_dir, "README.md")
+# if os.path.exists(markdown_file):
+#     os.remove(markdown_file)
+
+# 2. Save entire model
+model.save_pretrained(output_dir)

cpp/gemma_v1/training_multiturn.py

@@ -0,0 +1,329 @@
+import datasets
+datasets.config.DOWNLOADED_DATASETS_PATH = "/mnt/jeff/huggingface/data"
+import os
+os.environ['HF_HOME'] = '/mnt/jeff/huggingface'
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+import sacrebleu
+
+from datasets import load_dataset
+from torch.utils.data import Dataset, ConcatDataset
+from tqdm import tqdm
+from transformers import (
+    AutoProcessor,
+    AutoModel,
+    BatchFeature,
+    Trainer,
+    TrainingArguments,
+    StoppingCriteria,
+    StoppingCriteriaList,
+)
+from collections import defaultdict
+
+import soundfile as sf
+from datasets import Audio
+import random
+from ASRDataset import *
+
+
+def count_parameters_by_module(model):
+    # dictionary for parameters number by modules
+    module_params = defaultdict(lambda: {"total": 0, "trainable": 0})
+    
+    # all params
+    total_params = 0
+    total_trainable_params = 0
+    
+    # Check Embedding Token masks
+    embedding_masks = {}
+    for name, param in model.named_parameters():
+        if 'embed_tokens.weight' in name and hasattr(param, '_backward_hooks') and param._backward_hooks:
+            # check if params has embedding_grad_mask_hook
+            for hook_id, hook_fn in param._backward_hooks.items():
+                if hook_fn.__code__.co_name == 'embedding_grad_mask_hook':
+                    # Accessing mask variables in the closure of hook functions
+                    for cell in hook_fn.__closure__ or []:
+                        if isinstance(cell.cell_contents, torch.Tensor) and cell.cell_contents.dtype == torch.bool:
+                            # check mask tensor
+                            embedding_masks[name] = ~cell.cell_contents  # True : Trainable
+                 
+    # Count params by modules
+    for name, param in model.named_parameters():
+        # extracts top module_name
+        module_name = name.split('.')[0]
+        param_count = param.numel()
+        
+        module_params[module_name]["total"] += param_count
+        total_params += param_count
+        
+        if param.requires_grad:
+            # Only count for real trainable params. (with masks)
+            if name in embedding_masks:
+                trainable_count = embedding_masks[name].sum().item()
+                module_params[module_name]["trainable"] += trainable_count
+                total_trainable_params += trainable_count
+            else:
+                module_params[module_name]["trainable"] += param_count
+                total_trainable_params += param_count
+    
+    print(f"All Params: {total_params:,}")
+    print(f"Trainable Params: {total_trainable_params:,} ({total_trainable_params/total_params*100:.2f}%)")
+    print("\nParams by Module:")
+    
+    for module_name, counts in sorted(module_params.items()):
+        trainable_percentage = counts["trainable"] / counts["total"] * 100 if counts["total"] > 0 else 0
+        total_percentage = counts["total"] / total_params * 100
+        
+        print(f"- {module_name}:")
+        print(f"  Total: {counts['total']:,} ({total_percentage:.2f}% of model)")
+        print(f"  Trainable: {counts['trainable']:,} ({trainable_percentage:.2f}% of module)")
+    
+    return module_params
+
+def create_model(model_name_or_path, revision="main", use_flash_attention = False):
+    model = AutoModel.from_pretrained(
+        model_name_or_path,
+        revision=revision,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        attn_implementation="flash_attention_2" if use_flash_attention else "eager",
+        trust_remote_code=True,
+    )
+    
+    # Set use_cache to False after model loaded
+    model.config.use_cache = False
+
+    # Freeze all parameters
+    for param in model.parameters():
+        param.requires_grad = False
+    
+    model.set_lora_adapter('speech')
+    model.to(torch.bfloat16)
+    
+    # (Optional) unfreeze audio_tower parameters
+    # for param in model.audio_tower.parameters():
+    #    param.requires_grad = True
+
+    # Only unfreeze audio_projector parameters
+    # for param in model.audio_projector.parameters():
+    #     param.requires_grad = True
+
+    # (Optional) unfreeze audio embed_tokens
+    train_embed = True
+    if train_embed:
+        embed_tokens = model.language_model.model.model.embed_tokens
+        
+        embed_tokens.weight.requires_grad = False
+
+        # Added Speech token IDs (only this tokens be trainable)
+        trainable_token_ids = [256001, 256002]
+
+        embed_tokens.weight.requires_grad = True
+        mask = torch.ones_like(embed_tokens.weight, dtype=torch.bool)
+        mask[trainable_token_ids] = False  # Trainable Tokens are False (unfreeze), else True (freeze)
+
+        # backward hook, with gradient masking
+        def embedding_grad_mask_hook(grad):
+            return grad.masked_fill(mask, 0)
+
+        embed_tokens.weight.register_hook(embedding_grad_mask_hook)
+
+        model.language_model.model.model.embed_tokens = embed_tokens
+        
+    count_parameters_by_module(model)
+
+    return model
+
+ANSWER_SUFFIX = "<end_of_turn>"
+_IGNORE_INDEX = -100
+
+ANSWER_SUFFIX = "<end_of_turn>"
+_IGNORE_INDEX = -100
+
+model_name_or_path = '/mnt/jeff/gemma-3-4b-it-omni'
+use_flash_attention = False
+
+output_dir = '../gemma_tmp13'
+batch_size = 24
+batch_size_per_gpu = 8
+learning_rate = 4.0e-5 # 1.0e-4 for fine-tuning
+wd = 0.01
+num_train_epochs = 10
+
+revision = "main" #"v1.0"
+
+processor = AutoProcessor.from_pretrained(
+    model_name_or_path,
+    revision=revision,
+    trust_remote_code=True,
+)
+
+model = create_model(
+    model_name_or_path,
+    revision=revision,
+    use_flash_attention=use_flash_attention,
+)
+
+train_datasets = []
+
+pickup_dataset = MultiturnAudioDataset(processor=processor,json_path='/mnt/jeff/InCar/data/multiturn_data/pickup_processed.json')
+train_datasets.append(pickup_dataset)
+
+# custom_tw_loc = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_location-srdc_tts-20250509-common_voice_16_1-TW.csv')
+# train_datasets.append(custom_tw_loc) # 1500
+
+# custom_tw_loc2 = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_location-srdc_tts-20250529-common_voice_16_1-TW.csv')
+# train_datasets.append(custom_tw_loc2) # 9458
+
+# custom_yating_tw_road = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_road-srdc_tts-20250430-yating-1-2s-breezyvoice.csv')
+# train_datasets.append(custom_yating_tw_road) # 35224
+
+# custom_tw_road = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_road-srdc_tts-20250509-common_voice_16_1-TW.csv')
+# train_datasets.append(custom_tw_road) # 1500
+
+# custom_tw_road2 = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_road-srdc_tts-20250529-common_voice_16_1-TW.csv')
+# train_datasets.append(custom_tw_road2) # 35224
+
+
+
+print("Count Num of Datasets", len(train_datasets))
+print([len(dataset) for dataset in train_datasets])
+
+# ConcatDataset
+train_dataset = ConcatDataset(train_datasets) if len(train_datasets) > 1 else train_datasets[0]
+print("Count Length of Datas", len(train_dataset))
+
+
+
+# Check GPUs
+num_gpus = torch.cuda.device_count()
+print(f'training on {num_gpus} GPUs')
+
+assert (
+    batch_size % (num_gpus * batch_size_per_gpu) == 0
+), 'Batch size must be divisible by the number of GPUs'
+gradient_accumulation_steps = batch_size // (num_gpus * batch_size_per_gpu)
+
+# hard coded training args
+dp_config = {
+    "fp16": {
+      "enabled": "auto",
+      "loss_scale": 0,
+      "loss_scale_window": 1000,
+      "initial_scale_power": 16,
+      "hysteresis": 2,
+      "min_loss_scale": 1
+  },
+   "zero_optimization": {
+       "stage": 2,
+       "allgather_partitions": True,
+       "allgather_bucket_size": 5e8,
+       "overlap_comm": False,
+       "reduce_scatter": True,
+       "reduce_bucket_size": 5e8,
+       "contiguous_gradients": True,
+       "cpu_offload": True
+   },
+
+   "train_batch_size": "auto",
+    "gradient_accumulation_steps": "auto",
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+          "lr": "auto",
+          "betas": 'auto',
+          "eps": 'auto',
+          "weight_decay": "auto"
+        }
+    },
+    "scheduler": {
+      "type": "WarmupDecayLR",
+      "params": {
+          "warmup_min_lr": "auto",
+          "warmup_max_lr": "auto",
+          "warmup_num_steps": "auto",
+          "total_num_steps": "auto"
+      }
+  },
+    "gradient_clipping": 1.0,
+    "zero_optimization": {
+        "stage": 0
+    }
+}
+training_args = TrainingArguments(
+    num_train_epochs=num_train_epochs,
+    per_device_train_batch_size=batch_size_per_gpu,
+    gradient_checkpointing=True,
+    gradient_checkpointing_kwargs={'use_reentrant': False},
+    gradient_accumulation_steps=gradient_accumulation_steps,
+    optim='adamw_torch',
+    adam_beta1=0.9,
+    adam_beta2=0.95,
+    adam_epsilon=1e-7,
+    learning_rate=learning_rate,
+    weight_decay=wd,
+    max_grad_norm=1.0,
+    lr_scheduler_type='cosine',
+    warmup_steps=50,
+    logging_steps=10,
+    output_dir=output_dir,
+    save_total_limit=10,
+    save_only_model=True,
+    bf16=True,
+    fp16=False,
+    remove_unused_columns=False,
+    report_to='none',
+    deepspeed=None,
+    disable_tqdm=False,
+    dataloader_num_workers=16,
+    save_strategy='epoch',
+    # save_steps=2500,
+    ddp_find_unused_parameters=True,
+
+)
+
+out_path = Path(training_args.output_dir)
+out_path.mkdir(parents=True, exist_ok=True)
+
+# create optimizer only for trainable params
+optimizer = torch.optim.AdamW(
+    filter(lambda p: p.requires_grad, model.parameters()),
+    lr=learning_rate,
+    weight_decay=wd,
+    betas=(0.9, 0.95),
+    eps=1e-7,
+)
+
+# Trainer Setting
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    data_collator=covost_collate_fn,
+    train_dataset=train_dataset,
+    optimizers=(optimizer, None)
+)
+
+trainer.train()
+
+
+# # 1. Save LoRA Adapter
+model.language_model.model.save_pretrained(output_dir)
+
+# # 1-1. Delete Markdown file
+# markdown_file = os.path.join(output_dir, "README.md")
+# if os.path.exists(markdown_file):
+#     os.remove(markdown_file)
+
+# 2. Save entire model
+model.save_pretrained(output_dir)

cpp/gemma_v1/training_multiturn_textonly.py

@@ -0,0 +1,333 @@
+import datasets
+datasets.config.DOWNLOADED_DATASETS_PATH = "/mnt/jeff/huggingface/data"
+import os
+os.environ['HF_HOME'] = '/mnt/jeff/huggingface'
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+import sacrebleu
+
+from datasets import load_dataset
+from torch.utils.data import Dataset, ConcatDataset
+from tqdm import tqdm
+from transformers import (
+    AutoProcessor,
+    AutoModel,
+    BatchFeature,
+    Trainer,
+    TrainingArguments,
+    StoppingCriteria,
+    StoppingCriteriaList,
+)
+from collections import defaultdict
+
+import soundfile as sf
+from datasets import Audio
+import random
+from ASRDataset import *
+
+
+def count_parameters_by_module(model):
+    # dictionary for parameters number by modules
+    module_params = defaultdict(lambda: {"total": 0, "trainable": 0})
+    
+    # all params
+    total_params = 0
+    total_trainable_params = 0
+    
+    # Check Embedding Token masks
+    embedding_masks = {}
+    for name, param in model.named_parameters():
+        if 'embed_tokens.weight' in name and hasattr(param, '_backward_hooks') and param._backward_hooks:
+            # check if params has embedding_grad_mask_hook
+            for hook_id, hook_fn in param._backward_hooks.items():
+                if hook_fn.__code__.co_name == 'embedding_grad_mask_hook':
+                    # Accessing mask variables in the closure of hook functions
+                    for cell in hook_fn.__closure__ or []:
+                        if isinstance(cell.cell_contents, torch.Tensor) and cell.cell_contents.dtype == torch.bool:
+                            # check mask tensor
+                            embedding_masks[name] = ~cell.cell_contents  # True : Trainable
+                 
+    # Count params by modules
+    for name, param in model.named_parameters():
+        # extracts top module_name
+        module_name = name.split('.')[0]
+        param_count = param.numel()
+        
+        module_params[module_name]["total"] += param_count
+        total_params += param_count
+        
+        if param.requires_grad:
+            # Only count for real trainable params. (with masks)
+            if name in embedding_masks:
+                trainable_count = embedding_masks[name].sum().item()
+                module_params[module_name]["trainable"] += trainable_count
+                total_trainable_params += trainable_count
+            else:
+                module_params[module_name]["trainable"] += param_count
+                total_trainable_params += param_count
+    
+    print(f"All Params: {total_params:,}")
+    print(f"Trainable Params: {total_trainable_params:,} ({total_trainable_params/total_params*100:.2f}%)")
+    print("\nParams by Module:")
+    
+    for module_name, counts in sorted(module_params.items()):
+        trainable_percentage = counts["trainable"] / counts["total"] * 100 if counts["total"] > 0 else 0
+        total_percentage = counts["total"] / total_params * 100
+        
+        print(f"- {module_name}:")
+        print(f"  Total: {counts['total']:,} ({total_percentage:.2f}% of model)")
+        print(f"  Trainable: {counts['trainable']:,} ({trainable_percentage:.2f}% of module)")
+    
+    return module_params
+
+def create_model(model_name_or_path, revision="main", use_flash_attention = False):
+    model = AutoModel.from_pretrained(
+        model_name_or_path,
+        revision=revision,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        attn_implementation="flash_attention_2" if use_flash_attention else "eager",
+        trust_remote_code=True,
+    )
+    
+    # Set use_cache to False after model loaded
+    model.config.use_cache = False
+
+    # Freeze all parameters
+    for param in model.parameters():
+        param.requires_grad = False
+    
+    model.set_lora_adapter('speech')
+    # model.set_lora_adapter('text')
+    model.to(torch.bfloat16)
+    
+    # (Optional) unfreeze audio_tower parameters
+    # for param in model.audio_tower.parameters():
+    #    param.requires_grad = True
+
+    # Only unfreeze audio_projector parameters
+    # for param in model.audio_projector.parameters():
+    #     param.requires_grad = True
+
+    # (Optional) unfreeze audio embed_tokens
+    train_embed = True
+    if train_embed:
+        embed_tokens = model.language_model.model.model.embed_tokens
+        
+        embed_tokens.weight.requires_grad = False
+
+        # Added Speech token IDs (only this tokens be trainable)
+        trainable_token_ids = [256001, 256002]
+
+        embed_tokens.weight.requires_grad = True
+        mask = torch.ones_like(embed_tokens.weight, dtype=torch.bool)
+        mask[trainable_token_ids] = False  # Trainable Tokens are False (unfreeze), else True (freeze)
+
+        # backward hook, with gradient masking
+        def embedding_grad_mask_hook(grad):
+            return grad.masked_fill(mask, 0)
+
+        embed_tokens.weight.register_hook(embedding_grad_mask_hook)
+
+        model.language_model.model.model.embed_tokens = embed_tokens
+        
+    count_parameters_by_module(model)
+
+    return model
+
+ANSWER_SUFFIX = "<end_of_turn>"
+_IGNORE_INDEX = -100
+
+ANSWER_SUFFIX = "<end_of_turn>"
+_IGNORE_INDEX = -100
+
+model_name_or_path = '/mnt/jeff/gemma-3-4b-it-omni'
+use_flash_attention = False
+
+output_dir = '../gemma_tmp14_audio_and_text_speechlora'
+batch_size = 16
+batch_size_per_gpu = 1
+learning_rate = 5.0e-5 # 1.0e-4 for fine-tuning
+wd = 0.01
+num_train_epochs = 10
+
+revision = "main" #"v1.0"
+
+processor = AutoProcessor.from_pretrained(
+    model_name_or_path,
+    revision=revision,
+    trust_remote_code=True,
+)
+
+model = create_model(
+    model_name_or_path,
+    revision=revision,
+    use_flash_attention=use_flash_attention,
+)
+
+train_datasets = []
+
+pickup_dataset = MultiturnAudioDataset(processor=processor,text_only=True,json_path='/mnt/jeff/InCar/data/multiturn_data/pickup_processed.json')
+train_datasets.append(pickup_dataset)
+
+pickup_dataset = MultiturnAudioDataset(processor=processor,json_path='/mnt/jeff/InCar/data/multiturn_data/pickup_processed.json')
+train_datasets.append(pickup_dataset)
+
+# custom_tw_loc = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_location-srdc_tts-20250509-common_voice_16_1-TW.csv')
+# train_datasets.append(custom_tw_loc) # 1500
+
+# custom_tw_loc2 = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_location-srdc_tts-20250529-common_voice_16_1-TW.csv')
+# train_datasets.append(custom_tw_loc2) # 9458
+
+# custom_yating_tw_road = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_road-srdc_tts-20250430-yating-1-2s-breezyvoice.csv')
+# train_datasets.append(custom_yating_tw_road) # 35224
+
+# custom_tw_road = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_road-srdc_tts-20250509-common_voice_16_1-TW.csv')
+# train_datasets.append(custom_tw_road) # 1500
+
+# custom_tw_road2 = TWCostumData(processor=processor,
+#                       csv_path='/mnt/jeff/InCar/data/tw_data/taiwan_road-srdc_tts-20250529-common_voice_16_1-TW.csv')
+# train_datasets.append(custom_tw_road2) # 35224
+
+
+
+print("Count Num of Datasets", len(train_datasets))
+print([len(dataset) for dataset in train_datasets])
+
+# ConcatDataset
+train_dataset = ConcatDataset(train_datasets) if len(train_datasets) > 1 else train_datasets[0]
+print("Count Length of Datas", len(train_dataset))
+
+
+
+# Check GPUs
+num_gpus = torch.cuda.device_count()
+print(f'training on {num_gpus} GPUs')
+
+assert (
+    batch_size % (num_gpus * batch_size_per_gpu) == 0
+), 'Batch size must be divisible by the number of GPUs'
+gradient_accumulation_steps = batch_size // (num_gpus * batch_size_per_gpu)
+
+# hard coded training args
+dp_config = {
+    "fp16": {
+      "enabled": "auto",
+      "loss_scale": 0,
+      "loss_scale_window": 1000,
+      "initial_scale_power": 16,
+      "hysteresis": 2,
+      "min_loss_scale": 1
+  },
+   "zero_optimization": {
+       "stage": 2,
+       "allgather_partitions": True,
+       "allgather_bucket_size": 5e8,
+       "overlap_comm": False,
+       "reduce_scatter": True,
+       "reduce_bucket_size": 5e8,
+       "contiguous_gradients": True,
+       "cpu_offload": True
+   },
+
+   "train_batch_size": "auto",
+    "gradient_accumulation_steps": "auto",
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+          "lr": "auto",
+          "betas": 'auto',
+          "eps": 'auto',
+          "weight_decay": "auto"
+        }
+    },
+    "scheduler": {
+      "type": "WarmupDecayLR",
+      "params": {
+          "warmup_min_lr": "auto",
+          "warmup_max_lr": "auto",
+          "warmup_num_steps": "auto",
+          "total_num_steps": "auto"
+      }
+  },
+    "gradient_clipping": 1.0,
+    "zero_optimization": {
+        "stage": 0
+    }
+}
+training_args = TrainingArguments(
+    num_train_epochs=num_train_epochs,
+    per_device_train_batch_size=batch_size_per_gpu,
+    gradient_checkpointing=True,
+    gradient_checkpointing_kwargs={'use_reentrant': False},
+    gradient_accumulation_steps=gradient_accumulation_steps,
+    optim='adamw_torch',
+    adam_beta1=0.9,
+    adam_beta2=0.95,
+    adam_epsilon=1e-7,
+    learning_rate=learning_rate,
+    weight_decay=wd,
+    max_grad_norm=1.0,
+    lr_scheduler_type='cosine',
+    warmup_steps=50,
+    logging_steps=10,
+    output_dir=output_dir,
+    save_total_limit=10,
+    save_only_model=True,
+    bf16=True,
+    fp16=False,
+    remove_unused_columns=False,
+    report_to='none',
+    deepspeed=None,
+    disable_tqdm=False,
+    dataloader_num_workers=16,
+    save_strategy='epoch',
+    # save_steps=2500,
+    ddp_find_unused_parameters=True,
+
+)
+
+out_path = Path(training_args.output_dir)
+out_path.mkdir(parents=True, exist_ok=True)
+
+# create optimizer only for trainable params
+optimizer = torch.optim.AdamW(
+    filter(lambda p: p.requires_grad, model.parameters()),
+    lr=learning_rate,
+    weight_decay=wd,
+    betas=(0.9, 0.95),
+    eps=1e-7,
+)
+
+# Trainer Setting
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    data_collator=covost_collate_fn,
+    train_dataset=train_dataset,
+    optimizers=(optimizer, None)
+)
+
+trainer.train()
+
+
+# # 1. Save LoRA Adapter
+model.language_model.model.save_pretrained(output_dir)
+
+# # 1-1. Delete Markdown file
+# markdown_file = os.path.join(output_dir, "README.md")
+# if os.path.exists(markdown_file):
+#     os.remove(markdown_file)
+
+# 2. Save entire model
+model.save_pretrained(output_dir)

cpp/inference/audio_encoder_lib.cpp

@@ -0,0 +1,388 @@
+#include "audio_encoder_lib.h"
+
+#include <iostream>
+#include <fstream>
+#include <cmath>
+#include <numeric>
+#include <algorithm>
+#include <cstring> // For memcpy
+
+// Include specific ONNX Runtime headers for implementation
+#include <onnxruntime_cxx_api.h>
+
+// Include specific Eigen headers for implementation
+#include <Eigen/Dense>
+
+// Include specific KissFFT headers for implementation
+#include <kiss_fft.h>
+#include <kiss_fftr.h>
+
+// Define M_PI if it's not already defined
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+// --- Global parameters for feature extraction (matching Python script) ---
+// These are constants derived from the Python preprocessing script and are
+// internal to the feature extraction logic.
+namespace { // Anonymous namespace for internal linkage
+    const float PREEMPHASIS_COEFF = 0.97f;
+    const int N_FFT = 512;       // FFT size
+    const int WIN_LENGTH = 400;  // Window length (samples)
+    const int HOP_LENGTH = 160;  // Hop length (samples)
+    const int N_MELS = 80;       // Number of Mel filterbank channels
+    const int TARGET_SAMPLE_RATE = 16000; // Target sample rate for feature extraction
+}
+
+// --- Implementation of AudioInferenceEngine methods ---
+
+AudioInferenceEngine::AudioInferenceEngine(const std::string& modelPath) {
+    // 1. Initialize ONNX Runtime Environment
+    env_ = std::make_unique<Ort::Env>(ORT_LOGGING_LEVEL_WARNING, "AudioInferenceEngine");
+
+    // 2. Configure Session Options
+    Ort::SessionOptions session_options;
+    session_options.SetIntraOpNumThreads(0);
+    session_options.SetGraphOptimizationLevel(ORT_ENABLE_EXTENDED);
+
+    // 3. Create ONNX Runtime Session
+    session_ = std::make_unique<Ort::Session>(*env_, modelPath.c_str(), session_options);
+
+    // 4. Initialize Allocator
+    allocator_ = std::make_unique<Ort::AllocatorWithDefaultOptions>();
+
+    // 5. Get Input and Output Node Names
+    // It's crucial to allocate these names using the allocator and store them
+    // as C-style strings for Ort::Session::Run.
+    size_t numInputNodes = session_->GetInputCount();
+    if (numInputNodes == 0) {
+        throw Ort::Exception("ONNX model has no input nodes.", ORT_FAIL);
+    }
+    input_node_names_.resize(numInputNodes);
+    for (size_t i = 0; i < numInputNodes; ++i) {
+        input_node_names_[i] = session_->GetInputNameAllocated(i, *allocator_).release(); // release() to manage lifetime
+    }
+
+    size_t numOutputNodes = session_->GetOutputCount();
+    if (numOutputNodes == 0) {
+        throw Ort::Exception("ONNX model has no output nodes.", ORT_FAIL);
+    }
+    output_node_names_.resize(numOutputNodes);
+    for (size_t i = 0; i < numOutputNodes; ++i) {
+        output_node_names_[i] = session_->GetOutputNameAllocated(i, *allocator_).release(); // release() to manage lifetime
+    }
+
+    // 6. Precompute Mel filterbank
+    // The Python example uses fmax=16000//2-80-230.
+    float mel_fmax = static_cast<float>(TARGET_SAMPLE_RATE) / 2.0f - 80.0f - 230.0f;
+    mel_filterbank_ = speechlibMel(TARGET_SAMPLE_RATE, N_FFT, N_MELS, 0.0f, mel_fmax);
+
+    if (mel_filterbank_.rows() == 0 || mel_filterbank_.cols() == 0) {
+        throw std::runtime_error("Failed to create Mel filterbank during initialization.");
+    }
+
+    std::cout << "AudioInferenceEngine initialized successfully with model: " << modelPath << std::endl;
+}
+
+AudioInferenceEngine::~AudioInferenceEngine() {
+    // Release allocated names
+    for (const char* name : input_node_names_) {
+        allocator_->Free(const_cast<void*>(reinterpret_cast<const void*>(name)));
+    }
+    for (const char* name : output_node_names_) {
+        allocator_->Free(const_cast<void*>(reinterpret_cast<const void*>(name)));
+    }
+    // unique_ptr automatically handles deletion of env_ and session_
+}
+
+/**
+ * @brief Private helper: Loads audio data from a WAV file.
+ */
+std::vector<float> AudioInferenceEngine::loadWavToFloatArray(const std::string& filename, int& actual_sample_rate) {
+    std::ifstream file(filename, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Error: Could not open WAV file: " << filename << std::endl;
+        return {};
+    }
+
+    WavHeader header;
+    file.read(reinterpret_cast<char*>(&header), sizeof(WavHeader));
+
+    if (std::string(header.riff_id, 4) != "RIFF" ||
+        std::string(header.wave_id, 4) != "WAVE" ||
+        std::string(header.fmt_id, 4) != "fmt ") {
+        std::cerr << "Error: Invalid WAV header (RIFF, WAVE, or fmt chunk missing/invalid)." << std::endl;
+        file.close();
+        return {};
+    }
+
+    if (header.audio_format != 1) { // 1 = PCM
+        std::cerr << "Error: Only PCM audio format (1) is supported. Found: " << header.audio_format << std::endl;
+        file.close();
+        return {};
+    }
+
+    if (header.bits_per_sample != 16) {
+        std::cerr << "Error: Only 16-bit PCM is supported. Found: " << header.bits_per_sample << " bits per sample." << std::endl;
+        file.close();
+        return {};
+    }
+
+    actual_sample_rate = header.sample_rate;
+
+    WavDataChunk data_chunk;
+    bool data_chunk_found = false;
+    while (!file.eof()) {
+        file.read(reinterpret_cast<char*>(&data_chunk.data_id), 4);
+        file.read(reinterpret_cast<char*>(&data_chunk.data_size), 4);
+
+        if (std::string(data_chunk.data_id, 4) == "data") {
+            data_chunk_found = true;
+            break;
+        } else {
+            file.seekg(data_chunk.data_size, std::ios::cur);
+        }
+    }
+
+    if (!data_chunk_found) {
+        std::cerr << "Error: 'data' chunk not found in WAV file." << std::endl;
+        file.close();
+        return {};
+    }
+
+    std::vector<float> audioData;
+    int16_t sample_buffer;
+    long num_samples_to_read = data_chunk.data_size / sizeof(int16_t);
+
+    for (long i = 0; i < num_samples_to_read; ++i) {
+        file.read(reinterpret_cast<char*>(&sample_buffer), sizeof(int16_t));
+        float normalized_sample = static_cast<float>(sample_buffer) / 32768.0f;
+
+        if (header.num_channels == 1) {
+            audioData.push_back(normalized_sample);
+        } else if (header.num_channels == 2) {
+            int16_t right_sample;
+            if (file.read(reinterpret_cast<char*>(&right_sample), sizeof(int16_t))) {
+                float normalized_right_sample = static_cast<float>(right_sample) / 32768.0f;
+                audioData.push_back((normalized_sample + normalized_right_sample) / 2.0f);
+                i++;
+            } else {
+                std::cerr << "Warning: Unexpected end of file while reading stereo data." << std::endl;
+                break;
+            }
+        } else {
+            std::cerr << "Error: Unsupported number of channels: " << header.num_channels << std::endl;
+            file.close();
+            return {};
+        }
+    }
+
+    file.close();
+    return audioData;
+}
+
+/**
+ * @brief Private helper: Generates a Hamming window.
+ */
+std::vector<float> AudioInferenceEngine::generateHammingWindow(int window_length) {
+    std::vector<float> window(window_length);
+    for (int i = 0; i < window_length; ++i) {
+        window[i] = 0.54f - 0.46f * std::cos(2 * M_PI * i / static_cast<float>(window_length - 1));
+    }
+    return window;
+}
+
+/**
+ * @brief Private helper: Extracts spectrogram features.
+ */
+Eigen::MatrixXf AudioInferenceEngine::extractSpectrogram(const std::vector<float>& wav, int fs) {
+    int n_batch = (wav.size() - WIN_LENGTH) / HOP_LENGTH + 1;
+    if (n_batch <= 0) {
+        return Eigen::MatrixXf(0, N_FFT / 2 + 1);
+    }
+
+    std::vector<float> fft_window = generateHammingWindow(WIN_LENGTH);
+
+    kiss_fftr_cfg fft_cfg = kiss_fftr_alloc(N_FFT, 0 /* is_inverse_fft */, nullptr, nullptr);
+    if (!fft_cfg) {
+        std::cerr << "Error: Failed to allocate KissFFT configuration." << std::endl;
+        return Eigen::MatrixXf(0, N_FFT / 2 + 1);
+    }
+
+    Eigen::MatrixXf spec_matrix(n_batch, N_FFT / 2 + 1);
+
+    std::vector<float> frame_buffer(WIN_LENGTH);
+    kiss_fft_scalar fft_input[N_FFT];
+    kiss_fft_cpx fft_output[N_FFT / 2 + 1];
+
+    for (int i = 0; i < n_batch; ++i) {
+        int start_idx = i * HOP_LENGTH;
+
+        for (int j = 0; j < WIN_LENGTH; ++j) {
+            frame_buffer[j] = wav[start_idx + j];
+        }
+
+        // Apply pre-emphasis and scale by 32768
+        if (WIN_LENGTH > 0) {
+            if (WIN_LENGTH > 1) {
+                // Corrected pre-emphasis to match Python's np.roll and then overwrite first element
+                // The first element of the frame is pre-emphasized against the second element.
+                fft_input[0] = (frame_buffer[0] - PREEMPHASIS_COEFF * frame_buffer[1]) * 32768.0f;
+                for (int j = 1; j < WIN_LENGTH; ++j) {
+                    fft_input[j] = (frame_buffer[j] - PREEMPHASIS_COEFF * frame_buffer[j - 1]) * 32768.0f;
+                }
+            } else { // WIN_LENGTH == 1
+                fft_input[0] = frame_buffer[0] * 32768.0f;
+            }
+        }
+        for (int j = WIN_LENGTH; j < N_FFT; ++j) {
+            fft_input[j] = 0.0f;
+        }
+
+        for (int j = 0; j < WIN_LENGTH; ++j) {
+            fft_input[j] *= fft_window[j];
+        }
+
+        kiss_fftr(fft_cfg, fft_input, fft_output);
+
+        for (int j = 0; j <= N_FFT / 2; ++j) {
+            spec_matrix(i, j) = std::sqrt(fft_output[j].r * fft_output[j].r + fft_output[j].i * fft_output[j].i);
+        }
+    }
+
+    kiss_fftr_free(fft_cfg);
+    return spec_matrix;
+}
+
+/**
+ * @brief Private helper: Creates a Mel filter-bank matrix.
+ */
+Eigen::MatrixXf AudioInferenceEngine::speechlibMel(int sample_rate, int n_fft, int n_mels, float fmin, float fmax) {
+    int bank_width = n_fft / 2 + 1;
+    if (fmax == 0.0f) fmax = sample_rate / 2.0f;
+    if (fmin == 0.0f) fmin = 0.0f;
+
+    auto mel = [](float f) { return 1127.0f * std::log(1.0f + f / 700.0f); };
+    auto bin2mel = [&](int fft_bin) { return 1127.0f * std::log(1.0f + static_cast<float>(fft_bin) * sample_rate / (static_cast<float>(n_fft) * 700.0f)); };
+    auto f2bin = [&](float f) { return static_cast<int>((f * n_fft / sample_rate) + 0.5f); };
+
+    int klo = f2bin(fmin) + 1;
+    int khi = f2bin(fmax);
+    khi = std::max(khi, klo);
+
+    float mlo = mel(fmin);
+    float mhi = mel(fmax);
+    
+    std::vector<float> m_centers(n_mels + 2);
+    float ms = (mhi - mlo) / (n_mels + 1);
+    for (int i = 0; i < n_mels + 2; ++i) {
+        m_centers[i] = mlo + i * ms;
+    }
+
+    Eigen::MatrixXf matrix = Eigen::MatrixXf::Zero(n_mels, bank_width);
+
+    for (int m = 0; m < n_mels; ++m) {
+        float left = m_centers[m];
+        float center = m_centers[m + 1];
+        float right = m_centers[m + 2];
+        for (int fft_bin = klo; fft_bin < bank_width; ++fft_bin) {
+            float mbin = bin2mel(fft_bin);
+            if (left < mbin && mbin < right) {
+                matrix(m, fft_bin) = 1.0f - std::abs(center - mbin) / ms;
+            }
+        }
+    }
+    return matrix;
+}
+
+/**
+ * @brief Public method: Preprocesses an audio WAV file.
+ */
+Eigen::MatrixXf AudioInferenceEngine::preprocessAudio(const std::string& wavFilePath) {
+    int actual_wav_sample_rate = 0;
+    std::vector<float> audioWav = loadWavToFloatArray(wavFilePath, actual_wav_sample_rate);
+
+    if (audioWav.empty()) {
+        std::cerr << "Failed to load audio data from " << wavFilePath << "." << std::endl;
+        return Eigen::MatrixXf(0, N_MELS);
+    }
+
+    if (actual_wav_sample_rate != TARGET_SAMPLE_RATE) {
+        std::cerr << "Warning: WAV file sample rate (" << actual_wav_sample_rate
+                  << " Hz) does not match the target sample rate for feature extraction ("
+                  << TARGET_SAMPLE_RATE << " Hz)." << std::endl;
+        std::cerr << "This example does NOT include resampling. Features will be extracted at "
+                  << TARGET_SAMPLE_RATE << " Hz, which might lead to incorrect results if the WAV file's sample rate is different." << std::endl;
+    }
+
+    Eigen::MatrixXf spec = extractSpectrogram(audioWav, TARGET_SAMPLE_RATE);
+    if (spec.rows() == 0) {
+        std::cerr << "Error: Spectrogram extraction failed." << std::endl;
+        return Eigen::MatrixXf(0, N_MELS);
+    }
+
+    Eigen::MatrixXf spec_power = spec.array().square();
+    Eigen::MatrixXf fbank_power = spec_power * mel_filterbank_.transpose(); // Transpose mel_filterbank_ for correct multiplication
+
+    fbank_power = fbank_power.array().max(1.0f);
+    Eigen::MatrixXf log_fbank = fbank_power.array().log();
+
+    return log_fbank;
+}
+
+/**
+ * @brief Public method: Runs inference on the loaded ONNX model.
+ */
+std::vector<float> AudioInferenceEngine::runInference(const Eigen::MatrixXf& features) {
+    if (features.rows() == 0 || features.cols() == 0) {
+        std::cerr << "Error: Input features are empty for inference." << std::endl;
+        return {};
+    }
+
+    // Prepare Input Tensor Shape: [batch, frames, feature_size]
+    std::vector<int64_t> inputTensorShape = {1, features.rows(), features.cols()};
+
+    // Flatten Eigen::MatrixXf into std::vector<float> in row-major order
+    std::vector<float> inputTensorData(features.rows() * features.cols());
+    for (int r = 0; r < features.rows(); ++r) {
+        for (int c = 0; c < features.cols(); ++c) {
+            inputTensorData[r * features.cols() + c] = features(r, c);
+        }
+    }
+
+    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+    Ort::Value inputTensor = Ort::Value::CreateTensor<float>(memory_info, inputTensorData.data(), inputTensorData.size(),
+                                                              inputTensorShape.data(), inputTensorShape.size());
+
+    if (!inputTensor.IsTensor()) {
+        std::cerr << "Error: Created input tensor is not valid!" << std::endl;
+        return {};
+    }
+
+    // Run Inference
+    std::vector<Ort::Value> outputTensors = session_->Run(Ort::RunOptions{nullptr},
+                                                          input_node_names_.data(), &inputTensor, 1,
+                                                          output_node_names_.data(), output_node_names_.size());
+
+    if (outputTensors.empty() || !outputTensors[0].IsTensor()) {
+        std::cerr << "Error: No valid output tensors received from the model." << std::endl;
+        return {};
+    }
+
+    // Copy output data
+    float* outputData = outputTensors[0].GetTensorMutableData<float>();
+    Ort::TensorTypeAndShapeInfo outputShapeInfo = outputTensors[0].GetTensorTypeAndShapeInfo();
+    size_t outputSize = outputShapeInfo.GetElementCount();
+
+    std::vector<float> result(outputData, outputData + outputSize);
+    return result;
+}
+
+std::vector<Ort::Value> AudioInferenceEngine::runInference_tensor(const Ort::Value& inputTensor) {
+    // Run Inference
+    std::vector<Ort::Value> outputTensors = session_->Run(Ort::RunOptions{nullptr},
+                                                          input_node_names_.data(), &inputTensor, 1,
+                                                          output_node_names_.data(), output_node_names_.size());
+
+    return outputTensors;
+}

cpp/inference/audio_encoder_lib.h

@@ -0,0 +1,141 @@
+#ifndef AUDIO_INFERENCE_LIBRARY_H
+#define AUDIO_INFERENCE_LIBRARY_H
+
+#include <string>
+#include <vector>
+#include <cstdint> // For uint32_t, int16_t
+#include <memory>  // For std::unique_ptr
+#include <Eigen/Dense>
+using namespace Eigen;
+// Forward declarations for ONNX Runtime types to avoid including full headers in .h
+namespace Ort {
+    struct Env;
+    struct Session;
+    struct MemoryInfo;
+    struct AllocatorWithDefaultOptions;
+    struct Value;
+}
+
+// Forward declaration for Eigen Matrix
+namespace Eigen {
+    template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+    class Matrix;
+    typedef Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor, Eigen::Dynamic, Eigen::Dynamic> MatrixXf;
+}
+
+/**
+ * @brief Class to handle audio preprocessing and ONNX model inference.
+ *
+ * This class encapsulates the logic for loading WAV files, extracting Mel filterbank
+ * features, and running inference on an ONNX model.
+ */
+class AudioInferenceEngine {
+public:
+    /**
+     * @brief Constructor for AudioInferenceEngine.
+     * @param modelPath The file path to the ONNX model.
+     * @throws Ort::Exception if ONNX Runtime initialization fails.
+     */
+    AudioInferenceEngine(const std::string& modelPath);
+
+    /**
+     * @brief Destructor to clean up ONNX Runtime resources.
+     */
+    ~AudioInferenceEngine();
+
+    /**
+     * @brief Preprocesses an audio WAV file to extract Mel filterbank features.
+     *
+     * This function loads the WAV file, converts it to a float array, and then
+     * applies the spectrogram and Mel filterbank extraction steps.
+     *
+     * @param wavFilePath The path to the WAV audio file.
+     * @return An Eigen::MatrixXf containing the extracted features (frames x N_MELS).
+     * Returns an empty matrix if preprocessing fails.
+     */
+    Eigen::MatrixXf preprocessAudio(const std::string& wavFilePath);
+
+    /**
+     * @brief Runs inference on the loaded ONNX model using the provided features.
+     *
+     * The input features should be the output of `preprocessAudio`. This function
+     * converts the features to an ONNX Runtime tensor and executes the model.
+     *
+     * @param features An Eigen::MatrixXf containing the preprocessed audio features.
+     * Expected shape: (frames, N_MELS).
+     * @return A std::vector<float> containing the flattened output of the ONNX model.
+     * Returns an empty vector if inference fails.
+     */
+    std::vector<float> runInference(const Eigen::MatrixXf& features);
+    std::vector<Ort::Value> runInference_tensor(const Ort::Value& inputTensor);
+
+private:
+    // ONNX Runtime members
+    std::unique_ptr<Ort::Env> env_;
+    std::unique_ptr<Ort::Session> session_;
+    std::unique_ptr<Ort::AllocatorWithDefaultOptions> allocator_;
+    std::vector<const char*> input_node_names_;
+    std::vector<const char*> output_node_names_;
+
+    // Precomputed Mel filterbank matrix
+    Eigen::MatrixXf mel_filterbank_;
+
+    // Private helper functions (implemented in .cpp)
+    // WAV file parsing structures
+#pragma pack(push, 1)
+    struct WavHeader {
+        char     riff_id[4];
+        uint32_t file_size;
+        char     wave_id[4];
+        char     fmt_id[4];
+        uint32_t fmt_size;
+        uint16_t audio_format;
+        uint16_t num_channels;
+        uint32_t sample_rate;
+        uint32_t byte_rate;
+        uint16_t block_align;
+        uint16_t bits_per_sample;
+    };
+
+    struct WavDataChunk {
+        char     data_id[4];
+        uint32_t data_size;
+    };
+#pragma pack(pop)
+
+    /**
+     * @brief Loads audio data from a WAV file into a float vector.
+     * @param filename The path to the WAV audio file.
+     * @param actual_sample_rate Output parameter to store the sample rate read from the WAV file.
+     * @return A std::vector<float> containing the normalized mono audio samples.
+     */
+    std::vector<float> loadWavToFloatArray(const std::string& filename, int& actual_sample_rate);
+
+    /**
+     * @brief Generates a Hamming window.
+     * @param window_length The length of the window.
+     * @return A std::vector<float> containing the Hamming window coefficients.
+     */
+    std::vector<float> generateHammingWindow(int window_length);
+
+    /**
+     * @brief Extracts spectrogram features from waveform.
+     * @param wav The input waveform.
+     * @param fs The sampling rate.
+     * @return A 2D Eigen::MatrixXf representing the spectrogram.
+     */
+    Eigen::MatrixXf extractSpectrogram(const std::vector<float>& wav, int fs);
+
+    /**
+     * @brief Creates a Mel filter-bank matrix.
+     * @param sample_rate Sample rate in Hz.
+     * @param n_fft FFT size.
+     * @param n_mels Mel filter size.
+     * @param fmin Lowest frequency (in Hz).
+     * @param fmax Highest frequency (in Hz).
+     * @return An Eigen::MatrixXf representing the Mel transform matrix.
+     */
+    Eigen::MatrixXf speechlibMel(int sample_rate, int n_fft, int n_mels, float fmin, float fmax);
+};
+
+#endif // AUDIO_INFERENCE_LIBRARY_H

cpp/inference/compile.sh

@@ -0,0 +1,32 @@
+export BASE_DIR="/mnt/data-2t/jeff/codes/llm/cpp"
+# g++ test.cpp $BASE_DIR/kissfft/kiss_fft.c $BASE_DIR/kissfft/kiss_fftr.c \
+#     -o audio_inference \
+#     -I $BASE_DIR/onnxruntime-linux-x64-1.22.0/include \
+#     -I $BASE_DIR/eigen-3.4.0 \
+#     -I $BASE_DIR/kissfft \
+#     -L $BASE_DIR/kissfft/lib -lkissfft-int16_t-openmp \
+#     -L $BASE_DIR/onnxruntime-linux-x64-1.22.0/lib -lonnxruntime -std=c++17 -O2 -DNDEBUG
+
+g++ -c audio_encoder_lib.cpp \
+    -o audio_encoder_lib.o \
+    -I $BASE_DIR/onnxruntime-linux-x64-1.22.0/include  \
+    -I $BASE_DIR/eigen-3.4.0 \
+    -I $BASE_DIR/kissfft \
+    -std=c++17 -O3 -DNDEBUG -fPIC
+
+g++ -c $BASE_DIR/kissfft/kiss_fft.c \
+    -o kiss_fft.o \
+    -I $BASE_DIR/kissfft \
+    -std=c++17 -O3 -DNDEBUG -fPIC
+
+g++ -c $BASE_DIR/kissfft/kiss_fftr.c \
+    -o kiss_fftr.o \
+    -I $BASE_DIR/kissfft \
+    -std=c++17 -O3 -DNDEBUG -fPIC
+
+g++ main_text.cpp audio_encoder_lib.o kiss_fft.o kiss_fftr.o \
+    -o audio_inference_app \
+    -I $BASE_DIR/onnxruntime-linux-x64-1.22.0/include \
+    -I $BASE_DIR/eigen-3.4.0 \
+    -I $BASE_DIR/kissfft \
+    -L $BASE_DIR/onnxruntime-linux-x64-1.22.0/lib -lonnxruntime -std=c++17 -O3 -DNDEBUG

cpp/inference/main_text.cpp

@@ -0,0 +1,165 @@
+#include <iostream>
+#include <vector>
+#include <fstream>
+#include <string>
+#include <cmath> // For std::sin, M_PI
+#include <cstring> // For std::memcpy
+#include <chrono>  // For time measurement
+#include <random>  // For random number generation
+#include <ctime>   // For seeding random number generator
+
+// Include the new library header
+#include "audio_encoder_lib.h"
+#include <onnxruntime_cxx_api.h>
+// Define M_PI if it's not already defined
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+// --- WAV File Header Structures (for dummy file creation) ---
+#pragma pack(push, 1)
+struct WavHeader {
+    char     riff_id[4];
+    uint32_t file_size;
+    char     wave_id[4];
+    char     fmt_id[4];
+    uint32_t fmt_size;
+    uint16_t audio_format;
+    uint16_t num_channels;
+    uint32_t sample_rate;
+    uint32_t byte_rate;
+    uint16_t block_align;
+    uint16_t bits_per_sample;
+};
+
+struct WavDataChunk {
+    char     data_id[4];
+    uint32_t data_size;
+};
+#pragma pack(pop)
+
+// Function to write a dummy WAV file (moved here for example app)
+void createDummyWavFile(const std::string& filename, int sampleRate, int numChannels, int bitsPerSample, double durationSeconds) {
+    std::ofstream file(filename, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Error: Could not create dummy WAV file: " << filename << std::endl;
+        return;
+    }
+
+    WavHeader header;
+    std::memcpy(header.riff_id, "RIFF", 4);
+    std::memcpy(header.wave_id, "WAVE", 4);
+    std::memcpy(header.fmt_id, "fmt ", 4);
+    header.fmt_size = 16;
+    header.audio_format = 1; // PCM
+    header.num_channels = numChannels;
+    header.sample_rate = sampleRate;
+    header.bits_per_sample = bitsPerSample;
+    header.byte_rate = (sampleRate * numChannels * bitsPerSample) / 8;
+    header.block_align = (numChannels * bitsPerSample) / 8;
+
+    WavDataChunk data_chunk;
+    std::memcpy(data_chunk.data_id, "data", 4);
+    uint32_t num_samples = static_cast<uint32_t>(sampleRate * durationSeconds);
+    data_chunk.data_size = num_samples * numChannels * (bitsPerSample / 8);
+    header.file_size = 36 + data_chunk.data_size; // 36 is size of header before data chunk
+
+    file.write(reinterpret_cast<const char*>(&header), sizeof(WavHeader));
+    file.write(reinterpret_cast<const char*>(&data_chunk), sizeof(WavDataChunk));
+
+    // Generate a 440 Hz sine wave
+    for (uint32_t i = 0; i < num_samples; ++i) {
+        int16_t sample = static_cast<int16_t>(30000 * std::sin(2 * M_PI * 440 * i / static_cast<double>(sampleRate)));
+        for (int c = 0; c < numChannels; ++c) {
+            file.write(reinterpret_cast<const char*>(&sample), sizeof(int16_t));
+        }
+    }
+
+    file.close();
+    // std::cout << "Dummy WAV file '" << filename << "' created successfully." << std::endl; // Suppress verbose creation message
+}
+
+int main(int argc, char* argv[]) {
+    // --- 1. Process command-line arguments ---
+    if (argc != 3) {
+        std::cerr << "Usage: " << argv[0] << " <path_to_onnx_model> <path_to_wav_file_for_temp_use>" << std::endl;
+        std::cerr << "Example: " << argv[0] << " model.onnx temp_audio.wav" << std::endl;
+        return 1;
+    }
+
+    std::string onnxModelPath = argv[1];
+    std::string wavFilename = argv[2]; // This will be used as a temporary file
+
+    // --- Random number generation setup for dummy input frames ---
+    std::mt19937 rng(static_cast<unsigned int>(std::time(nullptr))); // Seed with current time
+    std::uniform_int_distribution<int> dist_frames(100, 300); // Distribution for frames (100 to 300)
+
+    // Define fixed parameters for feature extraction to calculate required duration
+    const int WIN_LENGTH = 400; // Window length (samples) - must match library's constant
+    const int HOP_LENGTH = 160; // Hop length (samples) - must match library's constant
+    const int TARGET_SAMPLE_RATE = 16000; // Target sample rate - must match library's constant
+
+    try {
+        // --- 2. Model Initialization ---
+        // This will load the ONNX model and precompute the Mel filterbank.
+        AudioInferenceEngine engine(onnxModelPath);
+        std::cout << "Engine initialized." << std::endl;
+
+        // --- 3. Model Inference and Time Measurement ---
+        std::cout << "\nRunning model inference and measuring time (100 runs with varying input sizes)..." << std::endl;
+        int num_runs = 100;
+        long long total_inference_time_us = 0; // Use microseconds for finer granularity
+
+        for (int i = 0; i < num_runs; ++i) {
+            // Generate a random number of frames for this run
+            int random_frames = dist_frames(rng);
+            // Calculate the number of samples needed to produce 'random_frames'
+            // frames = (num_samples - WIN_LENGTH) / HOP_LENGTH + 1
+            // num_samples = (frames - 1) * HOP_LENGTH + WIN_LENGTH
+            long long num_samples_for_frames = static_cast<long long>(random_frames - 1) * HOP_LENGTH + WIN_LENGTH;
+            double duration_seconds_for_frames = static_cast<double>(num_samples_for_frames) / TARGET_SAMPLE_RATE;
+
+            // Create a new dummy WAV file for this specific run
+            // This ensures the input size changes for each test.
+            createDummyWavFile(wavFilename, TARGET_SAMPLE_RATE, 1, 16, duration_seconds_for_frames);
+
+            // --- Measure the inference time ---
+            auto start_time = std::chrono::high_resolution_clock::now();
+            Eigen::MatrixXf features = engine.preprocessAudio(wavFilename);
+            std::vector<float> model_output = engine.runInference(features);
+            auto end_time = std::chrono::high_resolution_clock::now();
+
+            if (model_output.empty()) {
+                std::cerr << "Error: Model inference failed for run " << i + 1 << ". Exiting." << std::endl;
+                return 1;
+            }
+
+            // Calculate duration for this run in microseconds
+            auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
+            total_inference_time_us += duration.count();
+
+            // Optionally print output for the first run or specific runs
+            if (i == 0) {
+                std::cout << "First run (frames=" << features.rows() << ")"<< " take : "<< static_cast<double>(total_inference_time_us) / 1000.0 / 1000.0 <<"s output (first few elements): [";
+                for (size_t k = 0; k < std::min((size_t)10, model_output.size()); ++k) {
+                    std::cout << model_output[k] << (k == std::min((size_t)10, model_output.size()) - 1 ? "" : ", ");
+                }
+                std::cout << "]" << std::endl;
+            }
+        }
+
+        double average_inference_time_ms = static_cast<double>(total_inference_time_us) / num_runs / 1000.0 / 1000.0; // Convert microseconds to milliseconds
+        std::cout << "\nAverage ONNX model inference time over " << num_runs << " runs (with varying input frames): "
+                  << average_inference_time_ms << " s" << std::endl;
+
+    } catch (const Ort::Exception& e) {
+        std::cerr << "ONNX Runtime Exception: " << e.what() << std::endl;
+        return 1;
+    } catch (const std::exception& e) {
+        std::cerr << "Standard Exception: " << e.what() << std::endl;
+        return 1;
+    }
+
+    std::cout << "\nProgram finished successfully." << std::endl;
+    return 0;
+}

cpp/inference/run.sh

@@ -0,0 +1,7 @@
+export ONNXRUNTIME_DIR="/mnt/data-2t/jeff/codes/llm/cpp/onnxruntime-linux-x64-1.22.0"
+export LD_LIBRARY_PATH=$ONNXRUNTIME_DIR/lib:$LD_LIBRARY_PATH
+
+export MODEL_PATH="/mnt/data-2t/jeff/codes/llm/cpp/onnx_files/speech_init_export/phi-4-mm-speech.onnx"
+export SAMPLE_DATA="/mnt/data-2t/jeff/codes/llm/cpp/inference/dummy.wav"
+
+./audio_inference_app $MODEL_PATH $SAMPLE_DATA

cpp/inference/test copy 2.cpp

@@ -0,0 +1,567 @@
+#include <iostream>  // For standard input/output operations (e.g., std::cout, std::cerr)
+#include <vector>    // For dynamic arrays (e.g., std::vector<float>)
+#include <fstream>   // For file input/output operations (e.g., std::ifstream, std::ofstream)
+#include <cstdint>   // For fixed-width integer types (e.g., int16_t)
+#include <cmath>     // For mathematical functions (e.g., std::sin, M_PI, std::log)
+#include <numeric>   // For numerical operations (e.g., std::iota)
+#include <algorithm> // For algorithms like std::min, std::max
+#include <fstream>
+// Include the ONNX Runtime C++ API header
+#include <onnxruntime_cxx_api.h>
+
+// Include Eigen for powerful matrix operations.
+// You need to download Eigen and set up your include paths.
+// E.g., if Eigen is in 'C:/Libraries/eigen-3.4.0', you'd compile with -I C:/Libraries/eigen-3.4.0
+#include <Eigen/Dense>
+
+// Include KissFFT for Fast Fourier Transform.
+// You need to download KissFFT and set up your include paths.
+// E.g., if KissFFT is in 'C:/Libraries/kissfft-1.3.0', you'd compile with -I C:/Libraries/kissfft-1.3.0
+// You also need to compile kiss_fft.c and kiss_fftr.c and link them.
+#include "kiss_fft.h"
+#include "kiss_fftr.h" // For real-valued FFT
+
+// Define M_PI if it's not already defined by cmath or your compiler.
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+// --- Global parameters for feature extraction (matching Python script) ---
+const float PREEMPHASIS_COEFF = 0.97f;
+const int N_FFT = 512;       // FFT size
+const int WIN_LENGTH = 400;  // Window length (samples)
+const int HOP_LENGTH = 160;  // Hop length (samples)
+const int N_MELS = 80;       // Number of Mel filterbank channels
+const int TARGET_SAMPLE_RATE = 16000; // Target sample rate for feature extraction
+
+/**
+ * @brief Loads raw PCM audio data from a file into a float vector.
+ *
+ * This function reads 16-bit signed integer PCM samples from the specified file,
+ * converts them to floating-point values, and normalizes them to the range [-1.0, 1.0].
+ * It assumes the PCM data is little-endian.
+ *
+ * @param filename The path to the PCM audio file.
+ * @return A std::vector<float> containing the normalized audio samples, or an empty
+ * vector if the file cannot be opened.
+ */
+std::vector<float> loadPcmToFloatArray(const std::string& filename) {
+    std::ifstream file(filename, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Error: Could not open PCM file: " << filename << std::endl;
+        return {};
+    }
+
+    std::vector<float> audioData;
+    int16_t sample;
+
+    while (file.read(reinterpret_cast<char*>(&sample), sizeof(sample))) {
+        audioData.push_back(static_cast<float>(sample) / 32768.0f);
+    }
+
+    file.close();
+    return audioData;
+}
+
+/**
+ * @brief Generates a Hamming window.
+ * @param window_length The length of the window.
+ * @return A std::vector<float> containing the Hamming window coefficients.
+ */
+std::vector<float> generateHammingWindow(int window_length) {
+    std::vector<float> window(window_length);
+    for (int i = 0; i < window_length; ++i) {
+        window[i] = 0.54f - 0.46f * std::cos(2 * M_PI * i / static_cast<float>(window_length - 1));
+    }
+    return window;
+}
+
+/**
+ * @brief Extracts spectrogram features from waveform, matching Python's _extract_spectrogram.
+ *
+ * @param wav The input waveform (1D array of floats).
+ * @param fs The sampling rate of the waveform (fixed to 16000 Hz for this model).
+ * @return A 2D Eigen::MatrixXf representing the spectrogram (frames x (N_FFT/2 + 1)).
+ */
+Eigen::MatrixXf extractSpectrogram(const std::vector<float>& wav, int fs) {
+    // Calculate number of frames
+    int n_batch = (wav.size() - WIN_LENGTH) / HOP_LENGTH + 1;
+    if (n_batch <= 0) {
+        std::cerr << "Warning: Input waveform too short for feature extraction. Returning empty spectrogram." << std::endl;
+        return Eigen::MatrixXf(0, N_FFT / 2 + 1);
+    }
+
+    // Generate Hamming window once
+    std::vector<float> fft_window = generateHammingWindow(WIN_LENGTH);
+    // Initialize KissFFT for real-valued input
+    kiss_fftr_cfg fft_cfg = kiss_fftr_alloc(N_FFT, 0 /* is_inverse_fft */, nullptr, nullptr);
+    if (!fft_cfg) {
+        std::cerr << "Error: Failed to allocate KissFFT configuration." << std::endl;
+        return Eigen::MatrixXf(0, N_FFT / 2 + 1);
+    }
+
+    // Output spectrogram matrix: rows = frames, columns = FFT bins
+    Eigen::MatrixXf spec_matrix(n_batch, N_FFT / 2 + 1);
+
+    std::vector<float> frame_buffer(WIN_LENGTH);
+    std::vector<float> prev_frame_buffer(WIN_LENGTH);
+    kiss_fft_scalar fft_input[N_FFT]; // KissFFT requires input buffer of size N_FFT
+    kiss_fft_cpx fft_output[N_FFT / 2 + 1]; // KissFFT real output size
+    
+    for (int i = 0; i < n_batch; ++i) {
+        int start_idx = i * HOP_LENGTH;
+        
+        // Extract current frame
+        for (int j = 0; j < WIN_LENGTH; ++j) {
+            frame_buffer[j] = wav[start_idx + j];
+        }
+        
+        // Prepare previous frame for pre-emphasis (np.roll equivalent)
+        // y_frames_prev = np.roll(y_frames, 1, axis=1)
+        // y_frames_prev[:, 0] = y_frames_prev[:, 1]
+        prev_frame_buffer[0] = frame_buffer[0]; // Python's np.roll(..., 1) with axis=1 makes first element wrap around
+                                                // but then it's overwritten by y_frames_prev[:, 1]
+        if (WIN_LENGTH > 1) {
+            for (int j = 0; j < WIN_LENGTH - 1; ++j) {
+                prev_frame_buffer[j + 1] = frame_buffer[j];
+            }
+        }
+        // Correcting the first element as per Python code: y_frames_prev[:, 0] = y_frames_prev[:, 1]
+        // This means the first element of the 'previous' frame is actually the second element of the 'current' frame.
+        // For the first frame (i=0), prev_frame_buffer[0] should be frame_buffer[1] if WIN_LENGTH > 1.
+        // For subsequent frames, this logic applies to the *current* frame's first sample relative to its second.
+        // The original Python code effectively does:
+        // y_frames_prev = np.concatenate((y_frames[:, 1:2], y_frames[:, :-1]), axis=1)
+        // This is a bit tricky. Let's simplify and apply pre-emphasis directly to the current frame elements.
+        // The Python code applies pre-emphasis *within* each batch/frame.
+        // y_frames = (y_frames - preemphasis * y_frames_prev)
+        // y_frames_prev[:, 0] = y_frames_prev[:, 1] means the first element of the previous frame is taken from the second element of the *current* frame.
+        // This is equivalent to: frame[j] - preemphasis * (j == 0 ? frame[1] : frame[j-1])
+        // Let's use a temporary buffer for pre-emphasized frame.
+        std::vector<float> preemphasized_frame(WIN_LENGTH);
+        if (WIN_LENGTH > 0) {
+            preemphasized_frame[0] = frame_buffer[0]; // First sample is not pre-emphasized against a previous sample
+            if (WIN_LENGTH > 1) {
+                for (int j = 1; j < WIN_LENGTH; ++j) {
+                    preemphasized_frame[j] = frame_buffer[j] - PREEMPHASIS_COEFF * frame_buffer[j - 1];
+                }
+            }
+        }
+        // Apply pre-emphasis and scale by 32768 (as in Python)
+        for (int j = 0; j < WIN_LENGTH; ++j) {
+            fft_input[j] = preemphasized_frame[j] * 32768.0f;
+            // Pad with zeros if WIN_LENGTH < N_FFT
+            if (j >= WIN_LENGTH) {
+                fft_input[j] = 0.0f;
+            }
+        }
+        // Zero-pad the rest of the FFT input if WIN_LENGTH < N_FFT
+        for (int j = WIN_LENGTH; j < N_FFT; ++j) {
+            fft_input[j] = 0.0f;
+        }
+        // Apply Hamming window
+        for (int j = 0; j < WIN_LENGTH; ++j) {
+            fft_input[j] *= fft_window[j];
+        }
+        // Perform real FFT
+        kiss_fftr(fft_cfg, fft_input, fft_output);
+        // Calculate magnitude spectrogram
+        for (int j = 0; j <= N_FFT / 2; ++j) {
+            spec_matrix(i, j) = std::sqrt(fft_output[j].r * fft_output[j].r + fft_output[j].i * fft_output[j].i);
+        }
+    }
+    kiss_fftr_free(fft_cfg); // Free KissFFT configuration
+    return spec_matrix;
+}
+
+/**
+ * @brief Creates a Mel filter-bank matrix, matching Python's speechlib_mel.
+ *
+ * @param sample_rate Sample rate in Hz.
+ * @param n_fft FFT size.
+ * @param n_mels Mel filter size.
+ * @param fmin Lowest frequency (in Hz).
+ * @param fmax Highest frequency (in Hz).
+ * @return An Eigen::MatrixXf representing the Mel transform matrix (n_mels x (1 + n_fft/2)).
+ */
+Eigen::MatrixXf speechlibMel(int sample_rate, int n_fft, int n_mels, float fmin, float fmax) {
+    int bank_width = n_fft / 2 + 1;
+    if (fmax == 0.0f) fmax = sample_rate / 2.0f; // Use 0.0f as a sentinel for None
+    if (fmin == 0.0f) fmin = 0.0f; // Use 0.0f as a sentinel for None
+
+    // Helper functions for Mel scale conversion
+    auto mel = [](float f) { return 1127.0f * std::log(1.0f + f / 700.0f); };
+    auto bin2mel = [&](int fft_bin) { return 1127.0f * std::log(1.0f + static_cast<float>(fft_bin) * sample_rate / (static_cast<float>(n_fft) * 700.0f)); };
+    auto f2bin = [&](float f) { return static_cast<int>((f * n_fft / sample_rate) + 0.5f); };
+
+    // Spec 1: FFT bin range [f2bin(fmin) + 1, f2bin(fmax)]
+    int klo = f2bin(fmin) + 1;
+    int khi = f2bin(fmax);
+    khi = std::max(khi, klo);
+
+    // Spec 2: SpeechLib uses triangles in Mel space
+    float mlo = mel(fmin);
+    float mhi = mel(fmax);
+    
+    // Generate Mel centers
+    std::vector<float> m_centers(n_mels + 2);
+    float ms = (mhi - mlo) / (n_mels + 1);
+    for (int i = 0; i < n_mels + 2; ++i) {
+        m_centers[i] = mlo + i * ms;
+    }
+
+    Eigen::MatrixXf matrix = Eigen::MatrixXf::Zero(n_mels, bank_width);
+
+    for (int m = 0; m < n_mels; ++m) {
+        float left = m_centers[m];
+        float center = m_centers[m + 1];
+        float right = m_centers[m + 2];
+        for (int fft_bin = klo; fft_bin < bank_width; ++fft_bin) { // Loop up to bank_width-1
+            float mbin = bin2mel(fft_bin);
+            if (left < mbin && mbin < right) {
+                matrix(m, fft_bin) = 1.0f - std::abs(center - mbin) / ms;
+            }
+        }
+    }
+    matrix.transposeInPlace();
+    return matrix;
+}
+
+/**
+ * @brief Extracts log filterbank features from waveform, matching Python's _extract_features.
+ *
+ * @param wav The input waveform (1D array of floats).
+ * @param fs The sampling rate of the waveform (fixed to 16000 Hz).
+ * @param mel_filterbank The pre-computed Mel filterbank matrix.
+ * @return An Eigen::MatrixXf representing the log Mel filterbank features (frames x N_MELS).
+ */
+Eigen::MatrixXf extractFeatures(const std::vector<float>& wav, int fs, const Eigen::MatrixXf& mel_filterbank) {
+    // Extract spectrogram
+    Eigen::MatrixXf spec = extractSpectrogram(wav, fs);
+    if (spec.rows() == 0) {
+        return Eigen::MatrixXf(0, N_MELS); // Return empty matrix if spectrogram extraction failed
+    }
+
+    // spec_power = spec**2
+    Eigen::MatrixXf spec_power = spec.array().square();
+
+    // fbank_power = np.clip(spec_power.dot(_mel), 1.0, None)
+    // Note: Eigen's matrix multiplication is `*`, not `dot`.
+    // The Python `dot` for 2D arrays is matrix multiplication.
+    // Python: (frames, N_FFT/2+1) . (N_FFT/2+1, N_MELS) -> (frames, N_MELS)
+    // C++ Eigen: spec_power (rows, cols) * mel_filterbank (cols, N_MELS)
+    // So, mel_filterbank should be (N_FFT/2+1, N_MELS)
+    Eigen::MatrixXf fbank_power = spec_power * mel_filterbank;
+
+    // Apply clipping: np.clip(..., 1.0, None)
+    // This means any value less than 1.0 becomes 1.0.
+    fbank_power = fbank_power.array().max(1.0f);
+
+    // log_fbank = np.log(fbank_power).astype(np.float32)
+    Eigen::MatrixXf log_fbank = fbank_power.array().log();
+
+    return log_fbank;
+}
+
+
+int main(int argc, char* argv[]) {
+    // --- 1. Process command-line arguments ---
+    if (argc != 3) {
+        std::cerr << "Usage: " << argv[0] << " <path_to_onnx_model> <path_to_pcm_file>" << std::endl;
+        std::cerr << "Example: " << argv[0] << " model.onnx audio.pcm" << std::endl;
+        return 1;
+    }
+
+    std::string onnxModelPath = argv[1];
+    std::string pcmFilename = argv[2];
+
+    // --- Configuration for Audio and ONNX Model ---
+    // These are fixed by the Python preprocessor code and model requirements.
+    int bitDepth = 16;
+    // numChannels is handled within loadPcmToFloatArray and then implicitly by feature extraction
+    // which squeezes to 1D and takes mean if stereo. For simplicity, we assume mono PCM input.
+    // If your PCM is stereo, you'd need to adjust loadPcmToFloatArray to handle channel interleaving
+    // and then average or select a channel before passing to extractSpectrogram.
+    int numChannels = 1;
+
+    // --- Create a dummy PCM file if it doesn't exist for demonstration ---
+    // This is helpful for initial testing without needing an actual PCM file.
+    std::ifstream pcmCheck(pcmFilename, std::ios::binary);
+    if (!pcmCheck.is_open()) {
+        std::cerr << "PCM file '" << pcmFilename << "' not found. Creating a dummy one for demonstration." << std::endl;
+        std::ofstream dummyPcmFile(pcmFilename, std::ios::binary);
+        if (dummyPcmFile.is_open()) {
+            std::cout << "Creating a dummy PCM file: " << pcmFilename << " ("
+                      << (TARGET_SAMPLE_RATE * 2 * sizeof(int16_t)) / 1024 << " KB)" << std::endl;
+            for (int i = 0; i < TARGET_SAMPLE_RATE * 2; ++i) { // Generate 2 seconds of audio
+                int16_t sample = static_cast<int16_t>(30000 * std::sin(2 * M_PI * 440 * i / static_cast<double>(TARGET_SAMPLE_RATE)));
+                dummyPcmFile.write(reinterpret_cast<char*>(&sample), sizeof(sample));
+            }
+            dummyPcmFile.close();
+        } else {
+            std::cerr << "Error: Could not create dummy PCM file '" << pcmFilename
+                      << "'. Please ensure the directory is writable." << std::endl;
+            return 1;
+        }
+    } else {
+        pcmCheck.close();
+    }
+
+
+    // --- 2. Load PCM audio data into a float array ---
+    std::vector<float> audioWav = loadPcmToFloatArray(pcmFilename);
+
+    if (audioWav.empty()) {
+        std::cerr << "Failed to load audio data from " << pcmFilename << ". Exiting." << std::endl;
+        return 1;
+    }
+
+    std::cout << "Successfully loaded " << audioWav.size() << " samples from " << pcmFilename << std::endl;
+
+    // --- 3. Precompute Mel filterbank (as it's constant for a given sample rate/FFT size) ---
+    // The Python example uses fmax=16000//2-80-230. This translates to TARGET_SAMPLE_RATE/2 - 80 - 230.
+    // Using 0.0f for fmin as sentinel for None.
+    float mel_fmax = static_cast<float>(TARGET_SAMPLE_RATE) / 2.0f - 80.0f - 230.0f;
+    Eigen::MatrixXf mel_filterbank = speechlibMel(TARGET_SAMPLE_RATE, N_FFT, N_MELS, 0.0f, mel_fmax);
+
+    if (mel_filterbank.rows() == 0 || mel_filterbank.cols() == 0) {
+        std::cerr << "Error: Failed to create Mel filterbank. Exiting." << std::endl;
+        return 1;
+    }
+    std::cout << "Mel filterbank created with shape: [" << mel_filterbank.rows() << ", " << mel_filterbank.cols() << "]" << std::endl;
+
+
+    // --- 4. Apply feature extraction (preprocessor) ---
+    std::cout << "Extracting features from audio..." << std::endl;
+    Eigen::MatrixXf features = extractFeatures(audioWav, TARGET_SAMPLE_RATE, mel_filterbank);
+
+    std::ofstream outputFile("matrix_output.txt");
+    // Check if the file was opened successfully
+    if (outputFile.is_open()) {
+        // Iterate through rows and columns to write elements
+        for (int i = 0; i < features.rows(); ++i) {
+            for (int j = 0; j < features.cols(); ++j) {
+                outputFile << features(i, j); // Write the element
+                if (j < features.cols() - 1) {
+                    outputFile << ","; // Add a space separator between elements in a row
+                }
+            }
+            outputFile << std::endl; // Move to the next line after each row
+        }
+        outputFile.close(); // Close the file
+        std::cout << "Matrix successfully written to matrix_output.txt" << std::endl;
+    }
+
+
+    if (features.rows() == 0 || features.cols() == 0) {
+        std::cerr << "Error: Feature extraction resulted in an empty matrix. Exiting." << std::endl;
+        return 1;
+    }
+    std::cout << "Features extracted with shape: [" << features.rows() << ", " << features.cols() << "]" << std::endl;
+    std::cout << "First few feature values (first frame): [";
+    for (int i = 0; i < std::min((int)features.cols(), 5); ++i) {
+        std::cout << features(0, i) << (i == std::min((int)features.cols(), 5) - 1 ? "" : ", ");
+    }
+    std::cout << "]" << std::endl;
+
+    // --- 5. Check for ONNX model existence and provide guidance if missing ---
+    std::ifstream onnxModelCheck(onnxModelPath, std::ios::binary);
+    if (!onnxModelCheck.is_open()) {
+        std::cerr << "\nError: ONNX model file '" << onnxModelPath << "' not found." << std::endl;
+        std::cerr << "Please provide a valid ONNX model file. If you need a simple dummy one for testing, "
+                  << "you can create it using Python (e.g., with PyTorch) like this:" << std::endl;
+        std::cerr << "```python" << std::endl;
+        std::cerr << "import torch" << std::endl;
+        std::cerr << "import torch.nn as nn" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "class SimpleAudioModel(nn.Module):" << std::endl;
+        std::cerr << "    def __init__(self, input_frames, feature_size, output_size):" << std::endl;
+        std::cerr << "        super(SimpleAudioModel, self).__init__()" << std::endl;
+        std::cerr << "        # This model expects input of shape [batch_size, frames, feature_size]" << std::endl;
+        std::cerr << "        # Example: a simple linear layer that flattens input and processes it." << std::endl;
+        std::cerr << "        self.flatten = nn.Flatten()" << std::endl;
+        std::cerr << "        self.linear = nn.Linear(input_frames * feature_size, output_size)" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "    def forward(self, x):" << std::endl;
+        std::cerr << "        x = self.flatten(x)" << std::endl;
+        std::cerr << "        return self.linear(x)" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "# --- IMPORTANT: Define model input and output sizes. Adjust these to match your actual model's requirements. ---" << std::endl;
+        std::cerr << "# The C++ preprocessor will produce features of shape [frames, 80]." << std::endl;
+        std::cerr << "# For a dummy model, we need to provide a fixed 'frames' value for ONNX export." << std::endl;
+        std::cerr << "# A typical audio segment might be 2 seconds at 16kHz, which is 32000 samples." << std::endl;
+        std::cerr << "# Frames = (32000 - 400) / 160 + 1 = 198.75 + 1 = 199 frames (approx)" << std::endl;
+        std::cerr << "# Let's use a representative number of frames, e.g., 200 for a dummy input." << std::endl;
+        std::cerr << "DUMMY_INPUT_FRAMES = 200 # This should be representative of your typical audio segment's frames" << std::endl;
+        std::cerr << "DUMMY_FEATURE_SIZE = 80  # Fixed by the Mel filterbank (N_MELS)" << std::endl;
+        std::cerr << "DUMMY_OUTPUT_SIZE = 10   # Example: 10 classification scores or features" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "model = SimpleAudioModel(DUMMY_INPUT_FRAMES, DUMMY_FEATURE_SIZE, DUMMY_OUTPUT_SIZE)" << std::endl;
+        std::cerr << "dummy_input_tensor = torch.randn(1, DUMMY_INPUT_FRAMES, DUMMY_FEATURE_SIZE) # Batch size 1" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "torch.onnx.export(" << std::endl;
+        std::cerr << "    model," << std::endl;
+        std::cerr << "    dummy_input_tensor," << std::endl;
+        std::cerr << "    \"model.onnx\"," << std::endl;
+        std::cerr << "    verbose=True," << std::endl;
+        std::cerr << "    input_names=['input'],   # Name of the input tensor in the ONNX graph" << std::endl;
+        std::cerr << "    output_names=['output'], # Name of the output tensor in the ONNX graph" << std::endl;
+        std::cerr << "    # Define dynamic axes for batch_size and frames" << std::endl;
+        std::cerr << "    dynamic_axes={'input': {0: 'batch_size', 1: 'frames'}, 'output': {0: 'batch_size'}}" << std::endl;
+        std::cerr << ")" << std::endl;
+        std::cerr << "print(\"Dummy model.onnx created successfully. Remember to adjust DUMMY_INPUT_FRAMES in this script to match the expected number of frames from your audio segments.\")" << std::endl;
+        std::cerr << "```" << std::endl;
+        return 1;
+    }
+    onnxModelCheck.close();
+    std::cout << "ONNX model '" << onnxModelPath << "' found. Proceeding with inference." << std::endl;
+
+
+    // --- 6. ONNX Runtime Inference ---
+    try {
+        Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "AudioInference");
+        Ort::SessionOptions session_options;
+        session_options.SetIntraOpNumThreads(1);
+        // session_options.SetGraphOptimizationLevel(ORT_ENABLE_EXTENDED);
+
+        Ort::Session session(env, onnxModelPath.c_str(), session_options);
+        std::cout << "Model loaded successfully from: " << onnxModelPath << std::endl;
+        Ort::AllocatorWithDefaultOptions allocator;
+
+        // --- Get Input Node Information ---
+        size_t numInputNodes = session.GetInputCount();
+        std::vector<const char*> inputNodeNames(numInputNodes);
+
+        std::cout << "\n--- Model Input Information ---" << std::endl;
+        if (numInputNodes == 0) {
+            std::cerr << "Error: Model has no input nodes. Exiting." << std::endl;
+            return 1;
+        }
+
+        // Assuming a single input node for simplicity
+        inputNodeNames[0] = "audio_embeds";
+        Ort::TypeInfo type_info = session.GetInputTypeInfo(0);
+        auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
+        std::vector<int64_t> actualInputShape = tensor_info.GetShape();
+
+        std::cout << "  Input 0 : Name='" << inputNodeNames[0] << "', Shape=[";
+        for (size_t j = 0; j < actualInputShape.size(); ++j) {
+            // Print -1 for dynamic dimensions
+            if (actualInputShape[j] == -1) {
+                std::cout << "-1";
+            } else {
+                std::cout << actualInputShape[j];
+            }
+            std::cout << (j == actualInputShape.size() - 1 ? "" : ", ");
+        }
+        std::cout << "]" << std::endl;
+
+        // --- Prepare Input Tensor Shape ---
+        // The ONNX model input is [batch, frames, feature_size] = [-1, -1, 80]
+        // Our extracted features are [frames, 80]. We need to add a batch dimension of 1.
+        std::vector<int64_t> inputTensorShape = {1, features.rows(), features.cols()};
+        std::cout << "  Preparing input tensor with shape: [" << inputTensorShape[0] << ", "
+                  << inputTensorShape[1] << ", " << inputTensorShape[2] << "]" << std::endl;
+
+        // Flatten the Eigen::MatrixXf into a std::vector<float> for ONNX Runtime
+        std::vector<float> inputTensorData(features.data(), features.data() + features.size());
+
+        Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+        Ort::Value inputTensor = Ort::Value::CreateTensor<float>(memory_info, inputTensorData.data(), inputTensorData.size(),
+                                                                  inputTensorShape.data(), inputTensorShape.size());
+
+        if (!inputTensor.IsTensor()) {
+            std::cerr << "Error: Created input tensor is not valid! Exiting." << std::endl;
+            return 1;
+        }
+
+        // --- Get Output Node Information ---
+        size_t numOutputNodes = session.GetOutputCount();
+        std::vector<const char*> outputNodeNames(numOutputNodes);
+
+        std::cout << "\n--- Model Output Information ---" << std::endl;
+        for (size_t k = 0; k < numOutputNodes; ++k) {
+            outputNodeNames[k] = "audio_features";
+            Ort::TypeInfo type_info_out = session.GetOutputTypeInfo(k);
+            auto tensor_info_out = type_info_out.GetTensorTypeAndShapeInfo();
+            std::vector<int64_t> outputShape = tensor_info_out.GetShape();
+            std::cout << "  Output " << k << " : Name='" << outputNodeNames[k] << "', Shape=[";
+            for (size_t l = 0; l < outputShape.size(); ++l) {
+                if (outputShape[l] == -1) {
+                    std::cout << "-1";
+                } else {
+                    std::cout << outputShape[l];
+                }
+                std::cout << (l == outputShape.size() - 1 ? "" : ", ");
+            }
+            std::cout << "]" << std::endl;
+        }
+
+        // --- Run Inference ---
+        std::cout << "\nRunning ONNX model inference..." << std::endl;
+        std::vector<Ort::Value> outputTensors = session.Run(Ort::RunOptions{nullptr},
+                                                            inputNodeNames.data(), &inputTensor, 1,
+                                                            outputNodeNames.data(), numOutputNodes);
+        std::ofstream output_file("f0.txt");
+        for (auto& ort_value : outputTensors) {
+            // Example: Assuming Ort::Value contains a float tensor
+            if (ort_value.IsTensor()) {
+                float* data = ort_value.GetTensorMutableData<float>();
+                Ort::TensorTypeAndShapeInfo info = ort_value.GetTensorTypeAndShapeInfo();
+                size_t num_elements = info.GetElementCount();
+    
+                for (size_t i = 0; i < num_elements; ++i) {
+                    output_file << data[i];
+                    if (i < num_elements - 1) {
+                        output_file << ","; // Space separator between elements
+                    }
+                }
+                output_file << std::endl; // Newline after each Ort::Value's content
+            } else {
+                // Handle other Ort::Value types if necessary (e.g., sequences, maps)
+                output_file << "Non-tensor Ort::Value" << std::endl;
+            }
+        }
+    
+        output_file.close();
+
+
+        // --- Process Output ---
+        if (outputTensors.empty()) {
+            std::cerr << "Error: No output tensors received from the model." << std::endl;
+            return 1;
+        }
+
+        if (outputTensors[0].IsTensor()) {
+            float* outputData = outputTensors[0].GetTensorMutableData<float>();
+            Ort::TensorTypeAndShapeInfo outputShapeInfo = outputTensors[0].GetTensorTypeAndShapeInfo();
+            std::vector<int64_t> outputShape = outputShapeInfo.GetShape();
+            size_t outputSize = outputShapeInfo.GetElementCount();
+
+            std::cout << "\n--- Model Inference Result (first few elements) ---" << std::endl;
+            for (size_t k = 0; k < std::min((size_t)10, outputSize); ++k) {
+                std::cout << outputData[k] << (k == std::min((size_t)10, outputSize) - 1 ? "" : ", ");
+            }
+            std::cout << std::endl;
+
+            std::cout << "Full output tensor size: " << outputSize << " elements." << std::endl;
+            std::cout << "Full output tensor shape: [";
+            for (size_t k = 0; k < outputShape.size(); ++k) {
+                std::cout << outputShape[k] << (k == outputShape.size() - 1 ? "" : ", ");
+            }
+            std::cout << "]" << std::endl;
+        } else {
+            std::cerr << "Error: First output tensor is not of the expected type (float tensor)." << std::endl;
+        }
+
+    } catch (const Ort::Exception& e) {
+        std::cerr << "ONNX Runtime Exception: " << e.what() << std::endl;
+        return 1;
+    } catch (const std::exception& e) {
+        std::cerr << "Standard Exception: " << e.what() << std::endl;
+        return 1;
+    }
+
+    std::cout << "\nProgram finished successfully." << std::endl;
+    return 0;
+}

cpp/inference/test copy.cpp

@@ -0,0 +1,301 @@
+#include <iostream>
+#include <vector>
+#include <fstream>   // For file input/output operations (e.g., std::ifstream, std::ofstream)
+#include <cstdint>   // For fixed-width integer types (e.g., int16_t)
+#include <cmath>     // For mathematical functions (e.g., std::sin, M_PI)
+#include <numeric>   // For numerical operations (not strictly used in this version but often useful)
+#include <algorithm> // For algorithms like std::min
+
+// Include the ONNX Runtime C++ API header
+// You need to have ONNX Runtime installed and linked correctly in your build system.
+// For example, using CMake, you might add:
+// find_package(ONNXRuntime REQUIRED)
+// target_link_libraries(your_executable PRIVATE ONNXRuntime::onnxruntime_cxx_api)
+#include <onnxruntime_cxx_api.h>
+
+// Define M_PI if it's not already defined by cmath or your compiler.
+// This is common on Windows with MSVC unless _USE_MATH_DEFINES is set.
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+
+std::vector<float> loadPcmToFloatArray(const std::string& filename, int bitDepth, int numChannels) {
+    // Open the PCM file in binary mode for reading
+    std::ifstream file(filename, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Error: Could not open PCM file: " << filename << std::endl;
+        return {}; // Return empty vector on failure
+    }
+
+    std::vector<float> audioData; // Vector to store the normalized float audio samples
+
+    // Check if the bit depth is supported (this example only handles 16-bit)
+    if (bitDepth == 16) {
+        int16_t sample; // Buffer to read a single 16-bit sample
+
+        // Read samples until the end of the file
+        while (file.read(reinterpret_cast<char*>(&sample), sizeof(sample))) {
+            // Normalize 16-bit signed integer to float in range [-1.0, 1.0]
+            // The maximum positive value for int16_t is 32767.
+            // Dividing by 32768.0f (which is 2^15) ensures that 32767 maps to
+            // slightly less than 1.0, and -32768 maps to -1.0, maintaining
+            // the full dynamic range and avoiding overflow for -32768.
+            audioData.push_back(static_cast<float>(sample) / 32768.0f);
+        }
+    } else {
+        std::cerr << "Error: Unsupported bit depth: " << bitDepth << ". This example only supports 16-bit PCM." << std::endl;
+        return {}; // Return empty vector for unsupported bit depth
+    }
+
+    file.close(); // Close the file
+    return audioData; // Return the loaded audio data
+}
+
+int main() {
+    // --- Configuration for Audio and ONNX Model ---
+    std::string pcmFilename = "/mnt/data-2t/jeff/codes/llm/cpp/sample_data/pickup_breezy-common_voice_zh-TW_17376838-breezyvoice-00818.pcm"; // Name of the PCM audio file to load
+    int bitDepth = 16;                     // Bit depth of the PCM data (e.g., 16-bit)
+    int numChannels = 1;                   // Number of audio channels (e.g., 1 for mono)
+    int sampleRate = 16000;                // Sample rate of the audio (e.g., 16000 Hz)
+    std::string onnxModelPath = "/mnt/data-2t/jeff/codes/llm/cpp/onnx_files/speech_init_export/phi-4-mm-speech.onnx"; // Path to your ONNX model file
+
+    // --- 2. Load PCM audio data into a float array ---
+    std::vector<float> audioInput = loadPcmToFloatArray(pcmFilename, bitDepth, numChannels);
+
+    if (audioInput.empty()) {
+        std::cerr << "Failed to load audio data from " << pcmFilename << ". Exiting." << std::endl;
+        return 1; // Exit if audio data loading failed
+    }
+
+    std::cout << "Successfully loaded " << audioInput.size() << " samples from " << pcmFilename << std::endl;
+
+    // --- 3. Check for ONNX model existence and provide guidance if missing ---
+    // This step is critical. You need a valid ONNX model.
+    std::ifstream onnxModelCheck(onnxModelPath, std::ios::binary);
+    if (!onnxModelCheck.is_open()) {
+        std::cerr << "\nError: ONNX model file '" << onnxModelPath << "' not found." << std::endl;
+        std::cerr << "Please provide a valid ONNX model file. If you need a simple dummy one for testing, "
+                  << "you can create it using Python (e.g., with PyTorch) like this:" << std::endl;
+        std::cerr << "```python" << std::endl;
+        std::cerr << "import torch" << std::endl;
+        std::cerr << "import torch.nn as nn" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "class SimpleAudioModel(nn.Module):" << std::endl;
+        std::cerr << "    def __init__(self, input_size, output_size):" << std::endl;
+        std::cerr << "        super(SimpleAudioModel, self).__init__()" << std::endl;
+        std::cerr << "        # This is a very simple linear layer. Your actual model will be more complex." << std::endl;
+        std::cerr << "        # This model expects input of shape [batch_size, input_size]" << std::endl;
+        std::cerr << "        self.linear = nn.Linear(input_size, output_size)" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "    def forward(self, x):" << std::endl;
+        std::cerr << "        # If your model expects a different input shape (e.g., [batch_size, channels, samples])," << std::endl;
+        std::cerr << "        # you might need to reshape 'x' here before passing it to your layers (e.g., x.view(x.size(0), 1, -1))." << std::endl;
+        std::cerr << "        return self.linear(x)" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "# --- IMPORTANT: Define model input and output sizes. Adjust these to match your actual model's requirements. ---" << std::endl;
+        std::cerr << "# For this dummy model, we'll assume an input size matching our 2-second, 44.1kHz mono audio." << std::endl;
+        std::cerr << "DUMMY_INPUT_SIZE = " << (sampleRate * 2) << " # Corresponds to " << (sampleRate * 2) / static_cast<float>(sampleRate) << " seconds of audio at " << sampleRate << " Hz mono" << std::endl;
+        std::cerr << "DUMMY_OUTPUT_SIZE = 10   # Example: 10 classification scores or features" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "model = SimpleAudioModel(DUMMY_INPUT_SIZE, DUMMY_OUTPUT_SIZE)" << std::endl;
+        std::cerr << "dummy_input_tensor = torch.randn(1, DUMMY_INPUT_SIZE) # Batch size 1, DUMMY_INPUT_SIZE features" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "torch.onnx.export(" << std::endl;
+        std::cerr << "    model," << std::endl;
+        std::cerr << "    dummy_input_tensor," << std::endl;
+        std::cerr << "    \"model.onnx\"," << std::endl;
+        std::cerr << "    verbose=True," << std::endl;
+        std::cerr << "    input_names=['input'],   # Name of the input tensor in the ONNX graph" << std::endl;
+        std::cerr << "    output_names=['output'], # Name of the output tensor in the ONNX graph" << std::endl;
+        std::cerr << "    # Optional: Define dynamic axes if your batch size or sequence length can vary" << std::endl;
+        std::cerr << "    dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}}" << std::endl;
+        std::cerr << ")" << std::endl;
+        std::cerr << "print(\"Dummy model.onnx created successfully. Remember to adjust DUMMY_INPUT_SIZE in this script to match the length of your audio data or ensure your C++ code pads/truncates the audio data to the model's expected input size.\")" << std::endl;
+        std::cerr << "```" << std::endl;
+        return 1; // Exit if the ONNX model is not found
+    }
+    onnxModelCheck.close();
+    std::cout << "ONNX model '" << onnxModelPath << "' found. Proceeding with inference." << std::endl;
+
+
+    // --- 4. ONNX Runtime Inference ---
+    try {
+        // Create an ONNX Runtime environment. This is the entry point for all ONNX Runtime operations.
+        // ORT_LOGGING_LEVEL_WARNING suppresses verbose output unless there's a warning or error.
+        Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "AudioInference");
+
+        // Configure session options.
+        Ort::SessionOptions session_options;
+        session_options.SetIntraOpNumThreads(1);         // Use 1 thread for operations within a single node
+        session_options.SetGraphOptimizationLevel(ORT_ENABLE_EXTENDED); // Apply all available graph optimizations
+
+        // Create an ONNX Runtime session by loading the model.
+        Ort::Session session(env, onnxModelPath.c_str(), session_options);
+
+        // Get model input and output names and shapes.
+        // An allocator is needed to manage memory for allocated strings (like node names).
+        Ort::AllocatorWithDefaultOptions allocator;
+
+        // --- Get Input Node Information ---
+        size_t numInputNodes = session.GetInputCount();
+        std::vector<const char*> inputNodeNames(numInputNodes); // To store input node names
+
+        std::cout << "\n--- Model Input Information ---" << std::endl;
+        // Iterate through all input nodes (models usually have one main input)
+        for (size_t i = 0; i < numInputNodes; ++i) {
+            // Get the input node name
+            inputNodeNames[i] = session.GetInputNameAllocated(i, allocator).get();
+
+            // Get the type and shape information for the input tensor
+            Ort::TypeInfo type_info = session.GetInputTypeInfo(i);
+            auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
+            std::vector<int64_t> actualInputShape = tensor_info.GetShape(); // Get the shape the model *expects*
+
+            std::cout << "  Input " << i << " : Name='" << inputNodeNames[i] << "', Shape=[";
+            for (size_t j = 0; j < actualInputShape.size(); ++j) {
+                std::cout << actualInputShape[j] << (j == actualInputShape.size() - 1 ? "" : ", ");
+            }
+            std::cout << "]" << std::endl;
+
+            // --- Prepare Input Tensor Shape ---
+            // This is a CRITICAL step. The `audioInput` vector must be reshaped
+            // to precisely match the ONNX model's expected input tensor shape.
+            // The dummy Python model provided above creates an input of shape [1, DUMMY_INPUT_SIZE].
+            // We need to ensure `audioInput` matches `DUMMY_INPUT_SIZE` or pad/truncate it.
+            std::vector<int64_t> inputTensorShape; // This will be the shape of the tensor we create
+
+            if (actualInputShape.size() == 2 && actualInputShape[0] == 1) {
+                // Case: Model expects a 2D input with batch size 1 (e.g., [1, num_features])
+                int64_t expected_length = actualInputShape[1]; // The expected number of features/samples
+
+                // Check if the loaded audio data size matches the model's expected input length
+                if (audioInput.size() != expected_length) {
+                    std::cout << "  Warning: Loaded audio input size (" << audioInput.size()
+                              << ") does not match model's expected input length (" << expected_length << ")." << std::endl;
+                    std::cout << "  Padding/truncating audio data to match model input size." << std::endl;
+                    audioInput.resize(expected_length, 0.0f); // Pad with zeros or truncate the audio data
+                }
+                inputTensorShape = {1, expected_length}; // Set the tensor shape for ONNX Runtime
+            } else if (actualInputShape.size() == 1) {
+                // Case: Model expects a 1D input (e.g., [num_features])
+                int64_t expected_length = actualInputShape[0];
+
+                if (audioInput.size() != expected_length) {
+                    std::cout << "  Warning: Loaded audio input size (" << audioInput.size()
+                              << ") does not match model's expected input length (" << expected_length << ")." << std::endl;
+                    std::cout << "  Padding/truncating audio data to match model input size." << std::endl;
+                    audioInput.resize(expected_length, 0.0f); // Pad with zeros or truncate
+                }
+                inputTensorShape = {expected_length}; // Set the tensor shape for ONNX Runtime
+            } else {
+                std::cerr << "Error: Model input shape is not supported by this example ([N] or [1, N]). "
+                          << "Please adjust the input tensor shape creation logic in C++ to match your model's specific requirements." << std::endl;
+                return 1; // Exit if the input shape is not handled
+            }
+
+            // Create an ONNX Runtime memory info object for CPU memory.
+            // This specifies where the tensor data is located (CPU in this case).
+            Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+
+            // Create the input tensor from the audio data.
+            // `audioInput.data()` provides a pointer to the raw float data.
+            // `audioInput.size()` is the total number of elements.
+            // `inputTensorShape.data()` provides the shape array.
+            // `inputTensorShape.size()` is the number of dimensions.
+            Ort::Value inputTensor = Ort::Value::CreateTensor<float>(memory_info, audioInput.data(), audioInput.size(),
+                                                                      inputTensorShape.data(), inputTensorShape.size());
+
+            // Verify that the created input tensor is valid
+            if (!inputTensor.IsTensor()) {
+                std::cerr << "Error: Created input tensor is not valid! This might indicate a shape mismatch or data issue." << std::endl;
+                return 1; // Exit if the tensor is invalid
+            }
+
+            // At this point, `inputTensor` is ready to be fed into the model.
+            // For simplicity, we assume there's only one input to the model.
+            // If your model has multiple inputs, you'd need to create multiple Ort::Value objects.
+
+            // --- Get Output Node Information ---
+            size_t numOutputNodes = session.GetOutputCount();
+            std::vector<const char*> outputNodeNames(numOutputNodes); // To store output node names
+
+            std::cout << "\n--- Model Output Information ---" << std::endl;
+            // Iterate through all output nodes
+            for (size_t k = 0; k < numOutputNodes; ++k) {
+                outputNodeNames[k] = session.GetOutputNameAllocated(k, allocator).get();
+                Ort::TypeInfo type_info_out = session.GetOutputTypeInfo(k);
+                auto tensor_info_out = type_info_out.GetTensorTypeAndShapeInfo();
+                std::vector<int64_t> outputShape = tensor_info_out.GetShape();
+                std::cout << "  Output " << k << " : Name='" << outputNodeNames[k] << "', Shape=[";
+                for (size_t l = 0; l < outputShape.size(); ++l) {
+                    std::cout << outputShape[l] << (l == outputShape.size() - 1 ? "" : ", ");
+                }
+                std::cout << "]" << std::endl;
+            }
+
+            // --- Run Inference ---
+            std::cout << "\nRunning ONNX model inference..." << std::endl;
+            // The `session.Run` method executes the model.
+            // Arguments:
+            //   - Ort::RunOptions{nullptr}: Default run options.
+            //   - inputNodeNames.data(): Array of C-style strings for input names.
+            //   - &inputTensor: Pointer to the array of input tensors (here, just one).
+            //   - 1: Number of input tensors.
+            //   - outputNodeNames.data(): Array of C-style strings for output names.
+            //   - numOutputNodes: Number of output tensors expected.
+            std::vector<Ort::Value> outputTensors = session.Run(Ort::RunOptions{nullptr},
+                                                                inputNodeNames.data(), &inputTensor, 1,
+                                                                outputNodeNames.data(), numOutputNodes);
+
+            // --- Process Output ---
+            if (outputTensors.empty()) {
+                std::cerr << "Error: No output tensors received from the model." << std::endl;
+                return 1; // Exit if no output
+            }
+
+            // Assuming the first output is a float tensor (common for most models)
+            if (outputTensors[0].IsTensor()) {
+                // Get a mutable pointer to the raw data of the output tensor
+                float* outputData = outputTensors[0].GetTensorMutableData<float>();
+                Ort::TensorTypeAndShapeInfo outputShapeInfo = outputTensors[0].GetTensorTypeAndShapeInfo();
+                std::vector<int64_t> outputShape = outputShapeInfo.GetShape();
+                size_t outputSize = outputShapeInfo.GetElementCount(); // Total number of elements in the output tensor
+
+                std::cout << "\n--- Model Inference Result (first few elements) ---" << std::endl;
+                // Print the first 10 elements of the output (or fewer if output is smaller)
+                for (size_t k = 0; k < std::min((size_t)10, outputSize); ++k) {
+                    std::cout << outputData[k] << (k == std::min((size_t)10, outputSize) - 1 ? "" : ", ");
+                }
+                std::cout << std::endl;
+
+                std::cout << "Full output tensor size: " << outputSize << " elements." << std::endl;
+                std::cout << "Full output tensor shape: [";
+                for (size_t k = 0; k < outputShape.size(); ++k) {
+                    std::cout << outputShape[k] << (k == outputShape.size() - 1 ? "" : ", ");
+                }
+                std::cout << "]" << std::endl;
+
+                // Here you would typically interpret the model's output based on its purpose.
+                // For example:
+                // - For classification: Find the index of the maximum value (highest probability).
+                // - For regression: Use the numerical output directly.
+                // - For feature extraction: Use the output vector as features for further processing.
+            } else {
+                std::cerr << "Error: First output tensor is not of the expected type (float tensor)." << std::endl;
+            }
+        } // End of loop for input nodes (assuming single input for simplicity in this example)
+
+    } catch (const Ort::Exception& e) {
+        // Catch ONNX Runtime specific exceptions
+        std::cerr << "ONNX Runtime Exception: " << e.what() << std::endl;
+        return 1;
+    } catch (const std::exception& e) {
+        // Catch other standard exceptions
+        std::cerr << "Standard Exception: " << e.what() << std::endl;
+        return 1;
+    }
+
+    std::cout << "\nProgram finished successfully." << std::endl;
+    return 0;
+}

cpp/inference/test.cpp

@@ -0,0 +1,702 @@
+#include <iostream>  // For standard input/output operations (e.g., std::cout, std::cerr)
+#include <vector>    // For dynamic arrays (e.g., std::vector<float>)
+#include <fstream>   // For file input/output operations (e.g., std::ifstream, std::ofstream)
+#include <cstdint>   // For fixed-width integer types (e.g., int16_t, uint32_t)
+#include <cmath>     // For mathematical functions (e.g., std::sin, M_PI, std::log)
+#include <numeric>   // For numerical operations (e.g., std::iota)
+#include <algorithm> // For algorithms like std::min, std::max
+#include <string>    // For std::string
+
+// Include the ONNX Runtime C++ API header
+#include <onnxruntime_cxx_api.h>
+
+// Include Eigen for powerful matrix operations.
+// You need to download Eigen and set up your include paths.
+// E.g., if Eigen is in 'C:/Libraries/eigen-3.4.0', you'd compile with -I C:/Libraries/eigen-3.4.0
+#include <Eigen/Dense>
+
+// Include KissFFT for Fast Fourier Transform.
+// You need to download KissFFT and set up your include paths.
+// E.g., if KissFFT is in 'C:/Libraries/kissfft-1.3.0', you'd compile with -I C:/Libraries/kissfft-1.3.0
+// You also need to compile kiss_fft.c and kiss_fftr.c and link them.
+#include <kiss_fft.h>
+#include <kiss_fftr.h> // For real-valued FFT
+
+// Define M_PI if it's not already defined by cmath or your compiler.
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+// --- Global parameters for feature extraction (matching Python script) ---
+const float PREEMPHASIS_COEFF = 0.97f;
+const int N_FFT = 512;       // FFT size
+const int WIN_LENGTH = 400;  // Window length (samples)
+const int HOP_LENGTH = 160;  // Hop length (samples)
+const int N_MELS = 80;       // Number of Mel filterbank channels
+const int TARGET_SAMPLE_RATE = 16000; // Target sample rate for feature extraction
+
+// --- WAV File Header Structures ---
+// These structures are for parsing the WAV file format.
+// They assume little-endian byte order, which is standard for WAV files on most systems.
+#pragma pack(push, 1) // Ensure no padding for these structures
+
+struct WavHeader {
+    char     riff_id[4];     // Contains "RIFF"
+    uint32_t file_size;      // Size of the overall file - 8 bytes
+    char     wave_id[4];     // Contains "WAVE"
+    char     fmt_id[4];      // Contains "fmt " (note the space)
+    uint32_t fmt_size;       // Size of the fmt chunk (16 for PCM)
+    uint16_t audio_format;   // Audio format (1 for PCM)
+    uint16_t num_channels;   // Number of channels (1 for mono, 2 for stereo)
+    uint32_t sample_rate;    // Sample rate (e.g., 44100 Hz)
+    uint32_t byte_rate;      // (SampleRate * NumChannels * BitsPerSample) / 8
+    uint16_t block_align;    // (NumChannels * BitsPerSample) / 8
+    uint16_t bits_per_sample;// Bits per sample (e.g., 16)
+};
+
+struct WavDataChunk {
+    char     data_id[4];     // Contains "data"
+    uint32_t data_size;      // Size of the data chunk
+};
+
+#pragma pack(pop) // Restore default packing alignment
+
+/**
+ * @brief Loads audio data from a WAV file into a float vector.
+ *
+ * This function reads a WAV file, parses its header, extracts 16-bit signed
+ * integer PCM samples, converts them to floating-point values, and normalizes
+ * them to the range [-1.0, 1.0]. It supports mono and stereo (converting stereo to mono
+ * by averaging channels).
+ *
+ * @param filename The path to the WAV audio file.
+ * @param actual_sample_rate Output parameter to store the sample rate read from the WAV file.
+ * @return A std::vector<float> containing the normalized mono audio samples, or an empty
+ * vector if the file cannot be opened or is not a supported WAV format.
+ */
+std::vector<float> loadWavToFloatArray(const std::string& filename, int& actual_sample_rate) {
+    std::ifstream file(filename, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Error: Could not open WAV file: " << filename << std::endl;
+        return {};
+    }
+
+    WavHeader header;
+    file.read(reinterpret_cast<char*>(&header), sizeof(WavHeader));
+
+    // Basic header validation
+    if (std::string(header.riff_id, 4) != "RIFF" ||
+        std::string(header.wave_id, 4) != "WAVE" ||
+        std::string(header.fmt_id, 4) != "fmt ") {
+        std::cerr << "Error: Invalid WAV header (RIFF, WAVE, or fmt chunk missing/invalid)." << std::endl;
+        file.close();
+        return {};
+    }
+
+    if (header.audio_format != 1) { // 1 = PCM
+        std::cerr << "Error: Only PCM audio format (1) is supported. Found: " << header.audio_format << std::endl;
+        file.close();
+        return {};
+    }
+
+    if (header.bits_per_sample != 16) {
+        std::cerr << "Error: Only 16-bit PCM is supported. Found: " << header.bits_per_sample << " bits per sample." << std::endl;
+        file.close();
+        return {};
+    }
+
+    actual_sample_rate = header.sample_rate;
+    std::cout << "WAV file info: Sample Rate=" << header.sample_rate
+              << ", Channels=" << header.num_channels
+              << ", Bit Depth=" << header.bits_per_sample << std::endl;
+
+    // Find the "data" chunk
+    WavDataChunk data_chunk;
+    bool data_chunk_found = false;
+    while (!file.eof()) {
+        file.read(reinterpret_cast<char*>(&data_chunk.data_id), 4);
+        file.read(reinterpret_cast<char*>(&data_chunk.data_size), 4);
+
+        if (std::string(data_chunk.data_id, 4) == "data") {
+            data_chunk_found = true;
+            break;
+        } else {
+            // Skip unknown chunks
+            file.seekg(data_chunk.data_size, std::ios::cur);
+        }
+    }
+
+    if (!data_chunk_found) {
+        std::cerr << "Error: 'data' chunk not found in WAV file." << std::endl;
+        file.close();
+        return {};
+    }
+
+    std::vector<float> audioData;
+    int16_t sample_buffer;
+    long num_samples_to_read = data_chunk.data_size / sizeof(int16_t);
+
+    for (long i = 0; i < num_samples_to_read; ++i) {
+        file.read(reinterpret_cast<char*>(&sample_buffer), sizeof(int16_t));
+        float normalized_sample = static_cast<float>(sample_buffer) / 32768.0f;
+
+        if (header.num_channels == 1) {
+            audioData.push_back(normalized_sample);
+        } else if (header.num_channels == 2) {
+            // For stereo, read both left and right, then average for mono output
+            // Read next sample (right channel)
+            int16_t right_sample;
+            if (file.read(reinterpret_cast<char*>(&right_sample), sizeof(int16_t))) {
+                float normalized_right_sample = static_cast<float>(right_sample) / 32768.0f;
+                audioData.push_back((normalized_sample + normalized_right_sample) / 2.0f);
+                i++; // Increment i again as we read two samples
+            } else {
+                std::cerr << "Warning: Unexpected end of file while reading stereo data." << std::endl;
+                break;
+            }
+        } else {
+            std::cerr << "Error: Unsupported number of channels: " << header.num_channels << std::endl;
+            file.close();
+            return {};
+        }
+    }
+
+    file.close();
+    return audioData;
+}
+
+/**
+ * @brief Generates a Hamming window.
+ * @param window_length The length of the window.
+ * @return A std::vector<float> containing the Hamming window coefficients.
+ */
+std::vector<float> generateHammingWindow(int window_length) {
+    std::vector<float> window(window_length);
+    for (int i = 0; i < window_length; ++i) {
+        window[i] = 0.54f - 0.46f * std::cos(2 * M_PI * i / static_cast<float>(window_length - 1));
+    }
+    return window;
+}
+
+/**
+ * @brief Extracts spectrogram features from waveform, matching Python's _extract_spectrogram.
+ *
+ * @param wav The input waveform (1D array of floats).
+ * @param fs The sampling rate of the waveform (fixed to 16000 Hz for this model).
+ * @return A 2D Eigen::MatrixXf representing the spectrogram (frames x (N_FFT/2 + 1)).
+ */
+Eigen::MatrixXf extractSpectrogram(const std::vector<float>& wav, int fs) {
+    // Calculate number of frames
+    int n_batch = (wav.size() - WIN_LENGTH) / HOP_LENGTH + 1;
+    if (n_batch <= 0) {
+        std::cerr << "Warning: Input waveform too short for feature extraction. Returning empty spectrogram." << std::endl;
+        return Eigen::MatrixXf(0, N_FFT / 2 + 1);
+    }
+
+    // Generate Hamming window once
+    std::vector<float> fft_window = generateHammingWindow(WIN_LENGTH);
+
+    // Initialize KissFFT for real-valued input
+    kiss_fftr_cfg fft_cfg = kiss_fftr_alloc(N_FFT, 0 /* is_inverse_fft */, nullptr, nullptr);
+    if (!fft_cfg) {
+        std::cerr << "Error: Failed to allocate KissFFT configuration." << std::endl;
+        return Eigen::MatrixXf(0, N_FFT / 2 + 1);
+    }
+
+    // Output spectrogram matrix: rows = frames, columns = FFT bins
+    Eigen::MatrixXf spec_matrix(n_batch, N_FFT / 2 + 1);
+
+    std::vector<float> frame_buffer(WIN_LENGTH);
+    kiss_fft_scalar fft_input[N_FFT]; // KissFFT requires input buffer of size N_FFT
+    kiss_fft_cpx fft_output[N_FFT / 2 + 1]; // KissFFT real output size
+
+    for (int i = 0; i < n_batch; ++i) {
+        int start_idx = i * HOP_LENGTH;
+
+        // Extract current frame
+        for (int j = 0; j < WIN_LENGTH; ++j) {
+            frame_buffer[j] = wav[start_idx + j];
+        }
+
+        // Apply pre-emphasis and scale by 32768 (as in Python)
+        // Python: y_frames = (y_frames - preemphasis * y_frames_prev) * 32768
+        // where y_frames_prev[:, 0] = y_frames_prev[:, 1]
+        // This means for j=0, it's frame_buffer[0] - PREEMPHASIS_COEFF * frame_buffer[1]
+        // For j>0, it's frame_buffer[j] - PREEMPHASIS_COEFF * frame_buffer[j-1]
+        // Let's re-evaluate the pre-emphasis based on the Python snippet:
+        // y_frames_prev = np.roll(y_frames, 1, axis=1)
+        // y_frames_prev[:, 0] = y_frames_prev[:, 1]
+        // This means the first element of `y_frames_prev` for each frame is the second element of `y_frames`.
+        // So, for the first sample in a frame, it's `frame_buffer[0] - PREEMPHASIS_COEFF * frame_buffer[1]`.
+        // For subsequent samples, it's `frame_buffer[j] - PREEMPHASIS_COEFF * frame_buffer[j-1]`.
+        // This is a common pre-emphasis filter, but the first sample handling is specific.
+
+        // Corrected pre-emphasis implementation to match the Python `np.roll` behavior:
+        // The Python code effectively does:
+        // preemphasized_sample[0] = frame_buffer[0] - PREEMPHASIS_COEFF * frame_buffer[1] (if WIN_LENGTH > 1)
+        // preemphasized_sample[j] = frame_buffer[j] - PREEMPHASIS_COEFF * frame_buffer[j-1] for j > 0
+        // If WIN_LENGTH is 1, then it's just frame_buffer[0] (no pre-emphasis)
+        if (WIN_LENGTH > 0) {
+            if (WIN_LENGTH > 1) {
+                fft_input[0] = (frame_buffer[0] - PREEMPHASIS_COEFF * frame_buffer[1]) * 32768.0f;
+                for (int j = 1; j < WIN_LENGTH; ++j) {
+                    fft_input[j] = (frame_buffer[j] - PREEMPHASIS_COEFF * frame_buffer[j - 1]) * 32768.0f;
+                }
+            } else { // WIN_LENGTH == 1
+                fft_input[0] = frame_buffer[0] * 32768.0f;
+            }
+        }
+        // Zero-pad the rest of the FFT input if WIN_LENGTH < N_FFT
+        for (int j = WIN_LENGTH; j < N_FFT; ++j) {
+            fft_input[j] = 0.0f;
+        }
+
+        // Apply Hamming window
+        for (int j = 0; j < WIN_LENGTH; ++j) {
+            fft_input[j] *= fft_window[j];
+        }
+
+        // Perform real FFT
+        kiss_fftr(fft_cfg, fft_input, fft_output);
+
+        // Calculate magnitude spectrogram
+        for (int j = 0; j <= N_FFT / 2; ++j) {
+            spec_matrix(i, j) = std::sqrt(fft_output[j].r * fft_output[j].r + fft_output[j].i * fft_output[j].i);
+        }
+    }
+
+    kiss_fftr_free(fft_cfg); // Free KissFFT configuration
+    return spec_matrix;
+}
+
+/**
+ * @brief Creates a Mel filter-bank matrix, matching Python's speechlib_mel.
+ *
+ * @param sample_rate Sample rate in Hz.
+ * @param n_fft FFT size.
+ * @param n_mels Mel filter size.
+ * @param fmin Lowest frequency (in Hz).
+ * @param fmax Highest frequency (in Hz).
+ * @return An Eigen::MatrixXf representing the Mel transform matrix (n_mels x (1 + n_fft/2)).
+ */
+Eigen::MatrixXf speechlibMel(int sample_rate, int n_fft, int n_mels, float fmin, float fmax) {
+    int bank_width = n_fft / 2 + 1;
+    if (fmax == 0.0f) fmax = sample_rate / 2.0f; // Use 0.0f as a sentinel for None
+    if (fmin == 0.0f) fmin = 0.0f; // Use 0.0f as a sentinel for None
+
+    // Helper functions for Mel scale conversion
+    auto mel = [](float f) { return 1127.0f * std::log(1.0f + f / 700.0f); };
+    auto bin2mel = [&](int fft_bin) { return 1127.0f * std::log(1.0f + static_cast<float>(fft_bin) * sample_rate / (static_cast<float>(n_fft) * 700.0f)); };
+    auto f2bin = [&](float f) { return static_cast<int>((f * n_fft / sample_rate) + 0.5f); };
+
+    // Spec 1: FFT bin range [f2bin(fmin) + 1, f2bin(fmax)]
+    int klo = f2bin(fmin) + 1;
+    int khi = f2bin(fmax);
+    khi = std::max(khi, klo);
+
+    // Spec 2: SpeechLib uses triangles in Mel space
+    float mlo = mel(fmin);
+    float mhi = mel(fmax);
+    
+    // Generate Mel centers
+    std::vector<float> m_centers(n_mels + 2);
+    float ms = (mhi - mlo) / (n_mels + 1);
+    for (int i = 0; i < n_mels + 2; ++i) {
+        m_centers[i] = mlo + i * ms;
+    }
+
+    Eigen::MatrixXf matrix = Eigen::MatrixXf::Zero(n_mels, bank_width);
+
+    for (int m = 0; m < n_mels; ++m) {
+        float left = m_centers[m];
+        float center = m_centers[m + 1];
+        float right = m_centers[m + 2];
+        for (int fft_bin = klo; fft_bin < bank_width; ++fft_bin) { // Loop up to bank_width-1
+            float mbin = bin2mel(fft_bin);
+            if (left < mbin && mbin < right) {
+                matrix(m, fft_bin) = 1.0f - std::abs(center - mbin) / ms;
+            }
+        }
+    }
+    return matrix;
+}
+
+/**
+ * @brief Extracts log filterbank features from waveform, matching Python's _extract_features.
+ *
+ * @param wav The input waveform (1D array of floats).
+ * @param fs The sampling rate of the waveform (fixed to 16000 Hz).
+ * @param mel_filterbank The pre-computed Mel filterbank matrix.
+ * @return An Eigen::MatrixXf representing the log Mel filterbank features (frames x N_MELS).
+ */
+Eigen::MatrixXf extractFeatures(const std::vector<float>& wav, int fs, const Eigen::MatrixXf& mel_filterbank) {
+    // Extract spectrogram
+    Eigen::MatrixXf spec = extractSpectrogram(wav, fs);
+    if (spec.rows() == 0) {
+        return Eigen::MatrixXf(0, N_MELS); // Return empty matrix if spectrogram extraction failed
+    }
+
+    // spec_power = spec**2
+    Eigen::MatrixXf spec_power = spec.array().square();
+
+    // fbank_power = np.clip(spec_power.dot(_mel), 1.0, None)
+    // Note: Eigen's matrix multiplication is `*`, not `dot`.
+    // The Python `dot` for 2D arrays is matrix multiplication.
+    // Python: (frames, N_FFT/2+1) . (N_FFT/2+1, N_MELS) -> (frames, N_MELS)
+    // C++ Eigen: spec_power (rows, cols) * mel_filterbank (cols, N_MELS)
+    // So, mel_filterbank should be (N_FFT/2+1, N_MELS)
+    Eigen::MatrixXf fbank_power = spec_power * mel_filterbank.transpose(); // Transpose because Python's _mel is already transposed
+
+    // Apply clipping: np.clip(..., 1.0, None)
+    // This means any value less than 1.0 becomes 1.0.
+    fbank_power = fbank_power.array().max(1.0f);
+
+    // log_fbank = np.log(fbank_power).astype(np.float32)
+    Eigen::MatrixXf log_fbank = fbank_power.array().log();
+
+    return log_fbank;
+}
+
+// Function to write a dummy WAV file
+void createDummyWavFile(const std::string& filename, int sampleRate, int numChannels, int bitsPerSample, double durationSeconds) {
+    std::ofstream file(filename, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Error: Could not create dummy WAV file: " << filename << std::endl;
+        return;
+    }
+
+    WavHeader header;
+    std::memcpy(header.riff_id, "RIFF", 4);
+    std::memcpy(header.wave_id, "WAVE", 4);
+    std::memcpy(header.fmt_id, "fmt ", 4);
+    header.fmt_size = 16;
+    header.audio_format = 1; // PCM
+    header.num_channels = numChannels;
+    header.sample_rate = sampleRate;
+    header.bits_per_sample = bitsPerSample;
+    header.byte_rate = (sampleRate * numChannels * bitsPerSample) / 8;
+    header.block_align = (numChannels * bitsPerSample) / 8;
+
+    WavDataChunk data_chunk;
+    std::memcpy(data_chunk.data_id, "data", 4);
+    uint32_t num_samples = static_cast<uint32_t>(sampleRate * durationSeconds);
+    data_chunk.data_size = num_samples * numChannels * (bitsPerSample / 8);
+    header.file_size = 36 + data_chunk.data_size; // 36 is size of header before data chunk
+
+    file.write(reinterpret_cast<const char*>(&header), sizeof(WavHeader));
+    file.write(reinterpret_cast<const char*>(&data_chunk), sizeof(WavDataChunk));
+
+    // Generate a 440 Hz sine wave
+    for (uint32_t i = 0; i < num_samples; ++i) {
+        int16_t sample = static_cast<int16_t>(30000 * std::sin(2 * M_PI * 440 * i / static_cast<double>(sampleRate)));
+        for (int c = 0; c < numChannels; ++c) {
+            file.write(reinterpret_cast<const char*>(&sample), sizeof(int16_t));
+        }
+    }
+
+    file.close();
+    std::cout << "Dummy WAV file '" << filename << "' created successfully." << std::endl;
+}
+
+
+int main(int argc, char* argv[]) {
+    // --- 1. Process command-line arguments ---
+    if (argc != 3) {
+        std::cerr << "Usage: " << argv[0] << " <path_to_onnx_model> <path_to_wav_file>" << std::endl;
+        std::cerr << "Example: " << argv[0] << " model.onnx audio.wav" << std::endl;
+        return 1;
+    }
+
+    std::string onnxModelPath = argv[1];
+    std::string wavFilename = argv[2]; // Changed to wavFilename
+
+    // --- Configuration for Audio and ONNX Model ---
+    // These are fixed by the Python preprocessor code and model requirements.
+    // The actual sample rate will be read from the WAV file.
+    int actual_wav_sample_rate = 0;
+
+    // --- Create a dummy WAV file if it doesn't exist for demonstration ---
+    std::ifstream wavCheck(wavFilename, std::ios::binary);
+    if (!wavCheck.is_open()) {
+        std::cerr << "WAV file '" << wavFilename << "' not found. Creating a dummy one for demonstration." << std::endl;
+        // Create a 2-second, 16kHz, mono, 16-bit WAV file
+        createDummyWavFile(wavFilename, TARGET_SAMPLE_RATE, 1, 16, 2.0);
+    } else {
+        wavCheck.close();
+    }
+
+    // --- 2. Load WAV audio data into a float array ---
+    std::vector<float> audioWav = loadWavToFloatArray(wavFilename, actual_wav_sample_rate);
+
+    if (audioWav.empty()) {
+        std::cerr << "Failed to load audio data from " << wavFilename << ". Exiting." << std::endl;
+        return 1;
+    }
+
+    std::cout << "Successfully loaded " << audioWav.size() << " samples from " << wavFilename << std::endl;
+
+    // --- Validate WAV sample rate against target sample rate ---
+    if (actual_wav_sample_rate != TARGET_SAMPLE_RATE) {
+        std::cerr << "Warning: WAV file sample rate (" << actual_wav_sample_rate
+                  << " Hz) does not match the target sample rate for feature extraction ("
+                  << TARGET_SAMPLE_RATE << " Hz)." << std::endl;
+        std::cerr << "This example does NOT include resampling. Features will be extracted at "
+                  << TARGET_SAMPLE_RATE << " Hz, which might lead to incorrect results if the WAV file's sample rate is different." << std::endl;
+        // In a real application, you would implement resampling here (e.g., using libsamplerate).
+    }
+
+
+    // --- 3. Precompute Mel filterbank (as it's constant for a given sample rate/FFT size) ---
+    // The Python example uses fmax=16000//2-80-230. This translates to TARGET_SAMPLE_RATE/2 - 80 - 230.
+    // Using 0.0f for fmin as sentinel for None.
+    float mel_fmax = static_cast<float>(TARGET_SAMPLE_RATE) / 2.0f - 80.0f - 230.0f;
+    Eigen::MatrixXf mel_filterbank = speechlibMel(TARGET_SAMPLE_RATE, N_FFT, N_MELS, 0.0f, mel_fmax);
+
+    if (mel_filterbank.rows() == 0 || mel_filterbank.cols() == 0) {
+        std::cerr << "Error: Failed to create Mel filterbank. Exiting." << std::endl;
+        return 1;
+    }
+    std::cout << "Mel filterbank created with shape: [" << mel_filterbank.rows() << ", " << mel_filterbank.cols() << "]" << std::endl;
+
+
+    // --- 4. Apply feature extraction (preprocessor) ---
+    std::cout << "Extracting features from audio..." << std::endl;
+    Eigen::MatrixXf features = extractFeatures(audioWav, TARGET_SAMPLE_RATE, mel_filterbank);
+
+    ///// check input
+    // std::ofstream outputFile("matrix_output.txt");
+    // // Check if the file was opened successfully
+    // if (outputFile.is_open()) {
+    //     // Iterate through rows and columns to write elements
+    //     for (int i = 0; i < features.rows(); ++i) {
+    //         for (int j = 0; j < features.cols(); ++j) {
+    //             outputFile << features(i, j); // Write the element
+    //             if (j < features.cols() - 1) {
+    //                 outputFile << ","; // Add a space separator between elements in a row
+    //             }
+    //         }
+    //         outputFile << std::endl; // Move to the next line after each row
+    //     }
+    //     outputFile.close(); // Close the file
+    //     std::cout << "Matrix successfully written to matrix_output.txt" << std::endl;
+    // }
+
+    if (features.rows() == 0 || features.cols() == 0) {
+        std::cerr << "Error: Feature extraction resulted in an empty matrix. Exiting." << std::endl;
+        return 1;
+    }
+    std::cout << "Features extracted with shape: [" << features.rows() << ", " << features.cols() << "]" << std::endl;
+    std::cout << "First few feature values (first frame): [";
+    for (int i = 0; i < std::min((int)features.cols(), 5); ++i) {
+        std::cout << features(0, i) << (i == std::min((int)features.cols(), 5) - 1 ? "" : ", ");
+    }
+    std::cout << "]" << std::endl;
+
+    // --- 5. Check for ONNX model existence and provide guidance if missing ---
+    std::ifstream onnxModelCheck(onnxModelPath, std::ios::binary);
+    if (!onnxModelCheck.is_open()) {
+        std::cerr << "\nError: ONNX model file '" << onnxModelPath << "' not found." << std::endl;
+        std::cerr << "Please provide a valid ONNX model file. If you need a simple dummy one for testing, "
+                  << "you can create it using Python (e.g., with PyTorch) like this:" << std::endl;
+        std::cerr << "```python" << std::endl;
+        std::cerr << "import torch" << std::endl;
+        std::cerr << "import torch.nn as nn" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "class SimpleAudioModel(nn.Module):" << std::endl;
+        std::cerr << "    def __init__(self, input_frames, feature_size, output_size):" << std::endl;
+        std::cerr << "        super(SimpleAudioModel, self).__init__()" << std::endl;
+        std::cerr << "        # This model expects input of shape [batch_size, frames, feature_size]" << std::endl;
+        std::cerr << "        # Example: a simple linear layer that flattens input and processes it." << std::endl;
+        std::cerr << "        self.flatten = nn.Flatten()" << std::endl;
+        std::cerr << "        self.linear = nn.Linear(input_frames * feature_size, output_size)" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "    def forward(self, x):" << std::endl;
+        std::cerr << "        x = self.flatten(x)" << std::endl;
+        std::cerr << "        return self.linear(x)" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "# --- IMPORTANT: Define model input and output sizes. Adjust these to match your actual model's requirements. ---" << std::endl;
+        std::cerr << "# The C++ preprocessor will produce features of shape [frames, 80]." << std::endl;
+        std::cerr << "# For a dummy model, we need to provide a fixed 'frames' value for ONNX export." << std::endl;
+        std::cerr << "# A typical audio segment might be 2 seconds at 16kHz, which is 32000 samples." << std::endl;
+        std::cerr << "# Frames = (32000 - 400) / 160 + 1 = 198.75 + 1 = 199 frames (approx)" << std::endl;
+        std::cerr << "# Let's use a representative number of frames, e.g., 200 for a dummy input." << std::endl;
+        std::cerr << "DUMMY_INPUT_FRAMES = 200 # This should be representative of your typical audio segment's frames" << std::endl;
+        std::cerr << "DUMMY_FEATURE_SIZE = 80  # Fixed by the Mel filterbank (N_MELS)" << std::endl;
+        std::cerr << "DUMMY_OUTPUT_SIZE = 10   # Example: 10 classification scores or features" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "model = SimpleAudioModel(DUMMY_INPUT_FRAMES, DUMMY_FEATURE_SIZE, DUMMY_OUTPUT_SIZE)" << std::endl;
+        std::cerr << "dummy_input_tensor = torch.randn(1, DUMMY_INPUT_FRAMES, DUMMY_FEATURE_SIZE) # Batch size 1" << std::endl;
+        std::cerr << "" << std::endl;
+        std::cerr << "torch.onnx.export(" << std::endl;
+        std::cerr << "    model," << std::endl;
+        std::cerr << "    dummy_input_tensor," << std::endl;
+        std::cerr << "    \"model.onnx\"," << std::endl;
+        std::cerr << "    verbose=True," << std::endl;
+        std::cerr << "    input_names=['input'],   # Name of the input tensor in the ONNX graph" << std::endl;
+        std::cerr << "    output_names=['output'], # Name of the output tensor in the ONNX graph" << std::endl;
+        std::cerr << "    # Define dynamic axes for batch_size and frames" << std::endl;
+        std::cerr << "    dynamic_axes={'input': {0: 'batch_size', 1: 'frames'}, 'output': {0: 'batch_size'}}" << std::endl;
+        std::cerr << ")" << std::endl;
+        std::cerr << "print(\"Dummy model.onnx created successfully. Remember to adjust DUMMY_INPUT_FRAMES in this script to match the expected number of frames from your audio segments.\")" << std::endl;
+        std::cerr << "```" << std::endl;
+        return 1;
+    }
+    onnxModelCheck.close();
+    std::cout << "ONNX model '" << onnxModelPath << "' found. Proceeding with inference." << std::endl;
+
+
+    // --- 6. ONNX Runtime Inference ---
+    try {
+        Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "AudioInference");
+        Ort::SessionOptions session_options;
+        session_options.SetIntraOpNumThreads(1);
+        session_options.SetGraphOptimizationLevel(ORT_ENABLE_EXTENDED);
+
+        Ort::Session session(env, onnxModelPath.c_str(), session_options);
+        Ort::AllocatorWithDefaultOptions allocator;
+
+        // --- Get Input Node Information ---
+        size_t numInputNodes = session.GetInputCount();
+        std::vector<const char*> inputNodeNames(numInputNodes);
+
+        std::cout << "\n--- Model Input Information ---" << std::endl;
+        if (numInputNodes == 0) {
+            std::cerr << "Error: Model has no input nodes. Exiting." << std::endl;
+            return 1;
+        }
+
+        // Assuming a single input node for simplicity
+        inputNodeNames[0] = "audio_embeds";
+        Ort::TypeInfo type_info = session.GetInputTypeInfo(0);
+        auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
+        std::vector<int64_t> actualInputShape = tensor_info.GetShape();
+
+        std::cout << "  Input 0 : Name='" << inputNodeNames[0] << "', Shape=[";
+        for (size_t j = 0; j < actualInputShape.size(); ++j) {
+            // Print -1 for dynamic dimensions
+            if (actualInputShape[j] == -1) {
+                std::cout << "-1";
+            } else {
+                std::cout << actualInputShape[j];
+            }
+            std::cout << (j == actualInputShape.size() - 1 ? "" : ", ");
+        }
+        std::cout << "]" << std::endl;
+
+        // --- Prepare Input Tensor Shape ---
+        // The ONNX model input is [batch, frames, feature_size] = [-1, -1, 80]
+        // Our extracted features are [frames, 80]. We need to add a batch dimension of 1.
+        std::vector<int64_t> inputTensorShape = {1, features.rows(), features.cols()};
+        std::cout << "  Preparing input tensor with shape: [" << inputTensorShape[0] << ", "
+                  << inputTensorShape[1] << ", " << inputTensorShape[2] << "]" << std::endl;
+
+        // Flatten the Eigen::MatrixXf into a std::vector<float> for ONNX Runtime
+        // Eigen stores in column-major order by default. ONNX Runtime expects row-major
+        // for flattened 2D data when reshaped to 3D [1, frames, features].
+        // We need to copy elements row by row to ensure correct order.
+        std::vector<float> inputTensorData(features.rows() * features.cols());
+        for (int r = 0; r < features.rows(); ++r) {
+            for (int c = 0; c < features.cols(); ++c) {
+                inputTensorData[r * features.cols() + c] = features(r, c);
+            }
+        }
+
+        Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+        Ort::Value inputTensor = Ort::Value::CreateTensor<float>(memory_info, inputTensorData.data(), inputTensorData.size(),
+                                                                  inputTensorShape.data(), inputTensorShape.size());
+
+        if (!inputTensor.IsTensor()) {
+            std::cerr << "Error: Created input tensor is not valid! Exiting." << std::endl;
+            return 1;
+        }
+
+        // --- Get Output Node Information ---
+        size_t numOutputNodes = session.GetOutputCount();
+        std::vector<const char*> outputNodeNames(numOutputNodes);
+
+        std::cout << "\n--- Model Output Information ---" << std::endl;
+        for (size_t k = 0; k < numOutputNodes; ++k) {
+            outputNodeNames[k] = "audio_features";
+            Ort::TypeInfo type_info_out = session.GetOutputTypeInfo(k);
+            auto tensor_info_out = type_info_out.GetTensorTypeAndShapeInfo();
+            std::vector<int64_t> outputShape = tensor_info_out.GetShape();
+            std::cout << "  Output " << k << " : Name='" << outputNodeNames[k] << "', Shape=[";
+            for (size_t l = 0; l < outputShape.size(); ++l) {
+                if (outputShape[l] == -1) {
+                    std::cout << "-1";
+                } else {
+                    std::cout << outputShape[l];
+                }
+                std::cout << (l == outputShape.size() - 1 ? "" : ", ");
+            }
+            std::cout << "]" << std::endl;
+        }
+
+        // --- Run Inference ---
+        std::cout << "\nRunning ONNX model inference..." << std::endl;
+        std::vector<Ort::Value> outputTensors = session.Run(Ort::RunOptions{nullptr},
+                                                            inputNodeNames.data(), &inputTensor, 1,
+                                                            outputNodeNames.data(), numOutputNodes);
+
+        
+        // std::ofstream output_file("f0.txt");
+        // for (auto& ort_value : outputTensors) {
+        //     // Example: Assuming Ort::Value contains a float tensor
+        //     if (ort_value.IsTensor()) {
+        //         float* data = ort_value.GetTensorMutableData<float>();
+        //         Ort::TensorTypeAndShapeInfo info = ort_value.GetTensorTypeAndShapeInfo();
+        //         size_t num_elements = info.GetElementCount();
+    
+        //         for (size_t i = 0; i < num_elements; ++i) {
+        //             output_file << data[i];
+        //             if (i < num_elements - 1) {
+        //                 output_file << ","; // Space separator between elements
+        //             }
+        //         }
+        //         output_file << std::endl; // Newline after each Ort::Value's content
+        //     } else {
+        //         // Handle other Ort::Value types if necessary (e.g., sequences, maps)
+        //         output_file << "Non-tensor Ort::Value" << std::endl;
+        //     }
+        // }
+        // output_file.close();
+
+        // --- Process Output ---
+        if (outputTensors.empty()) {
+            std::cerr << "Error: No output tensors received from the model." << std::endl;
+            return 1;
+        }
+
+        if (outputTensors[0].IsTensor()) {
+            float* outputData = outputTensors[0].GetTensorMutableData<float>();
+            Ort::TensorTypeAndShapeInfo outputShapeInfo = outputTensors[0].GetTensorTypeAndShapeInfo();
+            std::vector<int64_t> outputShape = outputShapeInfo.GetShape();
+            size_t outputSize = outputShapeInfo.GetElementCount();
+
+            std::cout << "\n--- Model Inference Result (first few elements) ---" << std::endl;
+            for (size_t k = 0; k < std::min((size_t)10, outputSize); ++k) {
+                std::cout << outputData[k] << (k == std::min((size_t)10, outputSize) - 1 ? "" : ", ");
+            }
+            std::cout << std::endl;
+
+            std::cout << "Full output tensor size: " << outputSize << " elements." << std::endl;
+            std::cout << "Full output tensor shape: [";
+            for (size_t k = 0; k < outputShape.size(); ++k) {
+                std::cout << outputShape[k] << (k == outputShape.size() - 1 ? "" : ", ");
+            }
+            std::cout << "]" << std::endl;
+        } else {
+            std::cerr << "Error: First output tensor is not of the expected type (float tensor)." << std::endl;
+        }
+
+    } catch (const Ort::Exception& e) {
+        std::cerr << "ONNX Runtime Exception: " << e.what() << std::endl;
+        return 1;
+    } catch (const std::exception& e) {
+        std::cerr << "Standard Exception: " << e.what() << std::endl;
+        return 1;
+    }
+
+    std::cout << "\nProgram finished successfully." << std::endl;
+    return 0;
+}