Create app.py

app.py

@@ -0,0 +1,304 @@
+import gradio as gr
+
+class ConversionTool:
+    def __init__(self):
+        # Initialize widgets
+        self.intro = gr.Markdown("""
+
+```
+### # Optimum CLI Export Tool.. tool
+
+This tool helps organize the process of creating conversion commands when using Intel Optimum for Transformers to convert models outside of a script.. 
+
+
+My goal was to make it easier to construct commands for the  [Optimum CLI conversion tool](https://huggingface.co/docs/optimum/main/en/intel/openvino/export)  which enables converting models to the OpenVINO Intermediate Representation 
+outside of the from.pretrained method used in Transformers with the OpenVINO related classes like OVModelForCausalLM, OVModelForSeq2SeqLM, OVModelForQuestionAnswering, etc. 
+
+## Usage
+Here I'm assuming you have followed the instructions in the documentation and have all your dependencies in order.  
+
+Run to to get the latest.
+```
+pip install --upgrade --upgrade-strategy eager optimum[openvino]
+```
+
+Intended workflow:
+	-Select parameters.
+	-Copy command.
+	-Execute in your environment.
+
+Note: Converstion can take a while.
+      Expect slow performance and rejoice. After all, OpenVINO supports Intel CPUs from 6th gen forward, so you can 
+      squeeze performance 
+                                 
+## Discussion
+
+Leveraging hardware acceleration from OpenVINO requires converting a model into an Intermediate format derived from ONNX. Basically the command we execute rebuilds the model graph from it's source to be optimized for how OpenVINO uses this graph in memory. 
+
+Using OpenVINO effectively requires considering facts about what hardware the Intel PC running the code has available to it alongside details about the model you're working with.
+
+
+
+
+So here are some questions you should be able to answer before using this tool;
+- What data types does my CPU support? 
+- What instruction sets?
+- How will I be using the model?
+- Do I have enough system memory for this task?
+
+Visit the [Intel Ark  ]([Intel® Processors for PC, Laptops, Servers, and AI | Intel®](https://www.intel.com/content/www/us/en/products/details/processors.html)) product database to find this information. It's *the* ground truth on these sorts of specs. Even so, when testing with different model architecture
+
+   
+
+
+
+
+            """)
+
+
+        self.model_input = gr.Textbox(
+            label='Model',
+            placeholder='Model ID on huggingface.co or path on disk',
+            info="The model to convert. This can be a model ID on Hugging Face or a path on disk."
+        )
+        self.output_path = gr.Textbox(
+            label='Output Directory',
+            placeholder='Path to store the generated OV model',
+            info="We are storing some text here"
+        )
+        self.task = gr.Dropdown(
+            label='Task',
+            choices=['auto'] + [
+                'image-to-image', 'image-segmentation', 'inpainting',
+                'sentence-similarity', 'text-to-audio', 'image-to-text',
+                'automatic-speech-recognition', 'token-classification',
+                'text-to-image', 'audio-classification', 'feature-extraction',
+                'semantic-segmentation', 'masked-im', 'audio-xvector',
+                'audio-frame-classification', 'text2text-generation',
+                'multiple-choice', 'depth-estimation', 'image-classification',
+                'fill-mask', 'zero-shot-object-detection', 'object-detection',
+                'question-answering', 'zero-shot-image-classification',
+                'mask-generation', 'text-generation', 'text-classification'
+            ],
+            value=None
+        )
+        self.framework = gr.Dropdown(
+            label='Framework',
+            choices=['pt', 'tf'],
+            value=None
+        )
+        self.weight_format = gr.Dropdown(
+            label='Weight Format',
+            choices=['fp32', 'fp16', 'int8', 'int4', 'mxfp4', 'nf4'],
+            value=None,
+            info="The level of compression we apply to the intermediate representation."
+        )
+        self.library = gr.Dropdown(
+            label='Library',
+            choices=[
+                'auto', 'transformers', 'diffusers', 'timm',
+                'sentence_transformers', 'open_clip'
+            ],
+            value=None
+        )
+        self.ratio = gr.Number(
+            label='Ratio',
+            value=None,
+            minimum=0.0,
+            maximum=1.0,
+            step=0.1
+        )
+        self.group_size = gr.Number(
+            label='Group Size',
+            value=None,
+            step=1
+        )
+        self.backup_precision = gr.Dropdown(
+            label='Backup Precision',
+            choices=['', 'int8_sym', 'int8_asym'],
+            # value=None
+        )
+        self.dataset = gr.Dropdown(
+            label='Dataset',
+            choices=['none', 'auto', 'wikitext2', 'c4', 'c4-new', 'contextual',
+                    'conceptual_captions', 'laion/220k-GPT4Vision-captions-from-LIVIS',
+                    'laion/filtered-wit'],
+            value=None
+        )
+        self.trust_remote_code = gr.Checkbox(label='Trust Remote Code', value=False)
+        self.disable_stateful = gr.Checkbox(label='Disable Stateful', value=False, info="Disables stateful for inference. This is required for multi GPU inference due to how OpenVINO uses the KV cache. ")
+        self.disable_convert_tokenizer = gr.Checkbox(label='Disable Convert Tokenizer', value=False, info="Disables the tokenizer conversion. Use when models have custom tokenizers which might have formatting Optimum does not expect.")
+        self.all_layers = gr.Checkbox(label='All Layers', value=False)
+        self.awq = gr.Checkbox(label='AWQ', value=False, info="Activation aware quantization algorithm from NNCF. Requires a dataset, which can also be a path. ")
+        self.scale_estimation = gr.Checkbox(label='Scale Estimation', value=False)
+        self.gptq = gr.Checkbox(label='GPTQ', value=False)
+        self.lora_correction = gr.Checkbox(label='LoRA Correction', value=False)
+        self.sym = gr.Checkbox(label='Symmetric Quantization', value=False)
+        self.quant_mode = gr.Dropdown(
+            label='Quantization Mode',
+            choices=['sym', 'asym'],
+            value=None
+        )
+        self.cache_dir = gr.Textbox(
+            label='Cache Directory',
+            placeholder='Path to cache directory'
+        )
+        self.pad_token_id = gr.Number(
+            label='Pad Token ID',
+            value=None,
+            step=1,
+            info="Will infer from the model if not provided."
+        )
+        self.sensitivity_metric = gr.Dropdown(
+            label='Sensitivity Metric',
+            choices=['mse', 'snr'],
+            value=None
+        )
+        self.num_samples = gr.Number(
+            label='Number of Samples',
+            value=None,
+            step=1
+        )
+        self.smooth_quant_alpha = gr.Number(
+            label='Smooth Quant Alpha',
+            value=None,
+            minimum=0.0,
+            maximum=1.0,
+            step=0.1
+        )
+        self.command_output = gr.TextArea(
+            label='Generated Command',
+            placeholder='Generated command will appear here...',
+            show_label=True,
+            show_copy_button=True,
+            lines=5  # Adjust height
+        )
+
+    def construct_command(self, model_input, output_path, task, framework, weight_format, library,
+                          ratio, group_size, backup_precision, dataset,
+                          trust_remote_code, disable_stateful, disable_convert_tokenizer,
+                          all_layers, awq, scale_estimation, gptq, lora_correction, sym,
+                          quant_mode, cache_dir, pad_token_id, sensitivity_metric, num_samples,
+                          smooth_quant_alpha):
+        """Construct the command string"""
+        if not model_input or not output_path:
+            return ''
+        cmd_parts = ['optimum-cli export openvino']
+        
+        # Required arguments
+        cmd_parts.append(f'-m "{model_input}"')
+        cmd_parts.append(f'"{output_path}"')
+            
+        # Optional arguments
+        if task != 'auto':
+            cmd_parts.append(f'--task {task}')
+            
+        if framework != 'auto':
+            cmd_parts.append(f'--framework {framework}')
+                
+        if weight_format != 'fp32':
+            cmd_parts.append(f'--weight-format {weight_format}')
+                
+        if library != 'auto':
+            cmd_parts.append(f'--library {library}')
+                
+        if ratio != 1.0:
+            cmd_parts.append(f'--ratio {ratio}')
+                
+        if group_size != 128:
+            cmd_parts.append(f'--group-size {group_size}')
+                
+        if backup_precision != 'int8_asym':
+            cmd_parts.append(f'--backup-precision {backup_precision}')
+                
+        if dataset != 'none':
+            cmd_parts.append(f'--dataset {dataset}')
+                
+        # Flags
+        if trust_remote_code:
+            cmd_parts.append('--trust-remote-code')
+        if disable_stateful:
+            cmd_parts.append('--disable-stateful')
+        if disable_convert_tokenizer:
+            cmd_parts.append('--disable-convert-tokenizer')
+        if all_layers:
+            cmd_parts.append('--all-layers')
+        if awq:
+            cmd_parts.append('--awq')
+        if scale_estimation:
+            cmd_parts.append('--scale-estimation')
+        if gptq:
+            cmd_parts.append('--gptq')
+        if lora_correction:
+            cmd_parts.append('--lora-correction')
+        if sym:
+            cmd_parts.append('--sym')
+            
+        # New optional arguments
+        if quant_mode:
+            cmd_parts.append(f'--quant-mode {quant_mode}')
+        if cache_dir:
+            cmd_parts.append(f'--cache_dir {cache_dir}')
+        if pad_token_id:
+            cmd_parts.append(f'--pad-token-id {pad_token_id}')
+        if sensitivity_metric:
+            cmd_parts.append(f'--sensitivity-metric {sensitivity_metric}')
+        if num_samples:
+            cmd_parts.append(f'--num-samples {num_samples}')
+        if smooth_quant_alpha:
+            cmd_parts.append(f'--smooth-quant-alpha {smooth_quant_alpha}')
+            
+        constructed_command = ' '.join(cmd_parts)
+        return constructed_command
+
+    def gradio_app(self):
+        """Create and run the Gradio interface."""
+        inputs = [
+            self.model_input,
+            self.output_path,
+            self.task,
+            self.framework,
+            self.weight_format,
+            self.library,
+            self.ratio,
+            self.group_size,
+            self.backup_precision,
+            self.dataset,
+            self.trust_remote_code,
+            self.disable_stateful,
+            self.disable_convert_tokenizer,
+            self.all_layers,
+            self.awq,
+            self.scale_estimation,
+            self.gptq,
+            self.lora_correction,
+            self.sym,
+            self.quant_mode,
+            self.cache_dir,
+            self.pad_token_id,
+            self.sensitivity_metric,
+            self.num_samples,
+            self.smooth_quant_alpha,
+        ]
+        interface = gr.Interface(
+            fn=self.construct_command,
+            inputs=inputs,
+            outputs=self.command_output,
+            title="OpenVINO Conversion Tool",
+            description="Enter your model information to generate the `optimum-cli` command."
+        )
+
+        # Add custom CSS to make labels bold
+        interface.css = """
+        label {
+            font-weight: bold !important;
+        }
+        """
+
+        return interface
+    
+
+if __name__ == "__main__":
+    tool = ConversionTool()
+    app = tool.gradio_app()
+    app.launch(share = False)