version 08

.modelsignore

@@ -0,0 +1,18 @@
+# Models to ignore in the comparison tool
+# Each line is a pattern that can include wildcards (*)
+
+# Ignore specific repositories
+fbaldassarri/modello-italia-9b-autoround-w4g128-cpu,modello-italia-9bw4g128-cpu
+fbaldassarri/modello-italia-9b-autoround-w4g128-cpu,modello-italia-9bw4g128-gpu
+
+# Ignore model families with wildcards
+# *phi-2*
+# *llama-2-13b*
+# *mistral-7b*
+
+# Ignore by quantization type (all INT8 models)
+# *int8*
+
+# Ignore testing models
+# *test*
+# *experimental*

app.py

@@ -13,6 +13,7 @@ import numpy as np
 from functools import partial
 import gc
 import sys
+import fnmatch
 
 # Set page configuration
 st.set_page_config(
@@ -42,16 +43,68 @@ QUANTIZATION_KEYWORDS = [
     "autoawq", "auto_awq", "auto-awq"
 ]
 
+# Function to read and parse .modelsignore file
+def read_models_ignore_file(file_path=".modelsignore"):
+    """
+    Read the .modelsignore file and return a list of patterns to ignore.
+    Each line in the file represents a pattern.
+    """
+    ignore_patterns = []
+    try:
+        with open(file_path, 'r') as f:
+            for line in f:
+                # Strip whitespace and skip empty lines and comments
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    ignore_patterns.append(line)
+        return ignore_patterns
+    except FileNotFoundError:
+        return []  # Return empty list if file doesn't exist
+
+# Function to check if a model should be ignored
+def should_ignore_model(model_id, ignore_patterns):
+    """
+    Check if a model ID matches any pattern in the ignore list.
+    
+    Supports:
+    - Exact matches
+    - Glob patterns with wildcards (e.g., "*mistral*")
+    """
+    if not ignore_patterns:
+        return False
+        
+    for pattern in ignore_patterns:
+        # Check if the pattern matches using fnmatch (supports wildcards)
+        if fnmatch.fnmatch(model_id.lower(), pattern.lower()):
+            return True
+    
+    return False
+
 # Cache API results
 @st.cache_data(ttl=3600)  # Cache for 1 hour
-def get_user_models(username):
+def get_user_models(username, ignore_patterns=None):
     api = HfApi()
     try:
-        models = list(api.list_models(author=username))
-        return models
+        all_models = list(api.list_models(author=username))
+        model_ids = [model.id for model in all_models]
+        
+        # Filter out ignored models
+        if ignore_patterns:
+            filtered_models = []
+            ignored_models = []
+            
+            for model_id in model_ids:
+                if should_ignore_model(model_id, ignore_patterns):
+                    ignored_models.append(model_id)
+                else:
+                    filtered_models.append(model_id)
+            
+            return filtered_models, ignored_models, len(all_models)
+        
+        return model_ids, [], len(all_models)
     except Exception as e:
         st.error(f"Error fetching models: {str(e)}")
-        return []
+        return [], [], 0
 
 # Get model metadata without loading the model
 @st.cache_data(ttl=3600)
@@ -73,7 +126,7 @@ def model_matches_keywords(model_id):
 def extract_quantization_method(model_id):
     model_name = model_id.lower()
     
-    if any(kw in model_name for kw in ["auto_round", "auto-round", "autoround", "intel"]):
+    if any(kw in model_name for kw in ["auto_round", "auto-round", "autoround"]):
         return "Intel AutoRound"
     elif any(kw in model_name for kw in ["autogptq", "auto_gptq", "auto-gptq"]):
         return "AutoGPTQ"
@@ -257,21 +310,39 @@ def estimate_model_size_from_files(model_id):
 # Main function
 def main():
     st.title("🔍 Quantized Model Comparison Tool")
-    st.write("Compare Intel AutoRound, AutoGPTQ, and AutoAWQ models (optimized for free tier Space)")
+    st.write("Compare Intel AutoRound, AutoGPTQ, and AutoAWQ models")
+    
+    # Read the models ignore file
+    ignore_patterns = read_models_ignore_file()
     
     # Sidebar for configuration
     st.sidebar.header("Configuration")
     username = st.sidebar.text_input("HuggingFace Username", "fbaldassarri")
     
+    # Display ignore file status
+    if ignore_patterns:
+        st.sidebar.info(f"Using .modelsignore file with {len(ignore_patterns)} patterns")
+        if st.sidebar.expander("Show ignored patterns"):
+            for pattern in ignore_patterns:
+                st.sidebar.code(pattern)
+    else:
+        st.sidebar.info("No .modelsignore file found. All models will be included.")
+    
     # Fetch all models
     with st.spinner("Fetching models..."):
-        all_models = get_user_models(username)
-        all_model_ids = [model.id for model in all_models]
+        all_model_ids, ignored_models, total_models = get_user_models(username, ignore_patterns)
+    
+    # Show ignored models count if any
+    if ignored_models:
+        st.sidebar.warning(f"{len(ignored_models)} models ignored based on .modelsignore patterns")
+        with st.sidebar.expander("Show ignored models"):
+            for ignored in ignored_models:
+                st.sidebar.text(ignored)
     
     # Filter models with quantization keywords
     quantized_model_ids = [model_id for model_id in all_model_ids if model_matches_keywords(model_id)]
     
-    st.sidebar.write(f"Found {len(quantized_model_ids)} quantized models out of {len(all_model_ids)} total models")
+    st.sidebar.write(f"Found {len(quantized_model_ids)} quantized models out of {total_models} total models")
     
     # Quantization method filtering
     quant_methods = ["Intel AutoRound", "AutoGPTQ", "AutoAWQ"]
@@ -317,7 +388,7 @@ def main():
         model_selection_options = model_groups[selected_base_model]
     
     # Limit selection to prevent resource issues
-    max_models_comparison = st.sidebar.slider("Maximum models to compare", 2, len(quantized_model_ids), 5,)
+    max_models_comparison = st.sidebar.slider("Maximum models to compare", 2, len(quantized_model_ids), 5)
     default_models = model_selection_options[:min(max_models_comparison, len(model_selection_options))]
     
     selected_models = st.sidebar.multiselect(
@@ -673,6 +744,7 @@ def main():
         - **Repository Stats**: View downloads, likes, and update frequency
         - **Visualization**: Compare models across multiple dimensions
         - **Filtering**: Focus on specific quantization methods or model families
+        - **Model Ignoring**: Use .modelsignore file to exclude specific models
         
         ### Supported Quantization Methods:
         
@@ -682,10 +754,54 @@ def main():
         
         ### Instructions:
         
-        1. Select models using the sidebar filters
-        2. Click "Run Comparison" to analyze without loading full models
-        3. View results in the tabs and charts
-        4. Download results as CSV for further analysis
+        1. Create a .modelsignore file to exclude models (optional)
+        2. Select models using the sidebar filters
+        3. Click "Run Comparison" to analyze without loading full models
+        4. View results in the tabs and charts
+        5. Download results as CSV for further analysis
+        
+        ### .modelsignore Format:
+        
+        Add one pattern per line to ignore specific models:
+        ```
+        # Comments start with #
+        fbaldassarri/llama-2-7b-*  # Ignores all llama-2-7b models
+        *mistral*                  # Ignores anything with "mistral" in the name
+        fbaldassarri/exact-model-name  # Ignores a specific model
+        ```
+        """)
+
+    # Add a section about the modelsignore file format
+    with st.expander("How to use .modelsignore file"):
+        st.markdown("""
+        ### .modelsignore File Format
+        
+        Create a file named `.modelsignore` in the same directory as app.py. Each line in this file represents a pattern for models to exclude from comparison.
+        
+        #### Pattern Format:
+        - **Exact match**: `fbaldassarri/model-name`
+        - **Wildcard match**: `*keyword*` (matches any model with "keyword" in the name)
+        - **Prefix match**: `fbaldassarri/prefix*` (matches models starting with "prefix")
+        - **Suffix match**: `*suffix` (matches models ending with "suffix")
+        
+        #### Example .modelsignore file:
+        ```
+        # Comments start with #
+        
+        # Ignore specific models
+        fbaldassarri/llama-2-7b-auto-gptq
+        
+        # Ignore all models containing "phi" and "3b"
+        *phi*3b*
+        
+        # Ignore all models starting with "gemma-"
+        fbaldassarri/gemma-*
+        
+        # Ignore all mistral models
+        *mistral*
+        ```
+        
+        The tool will read this file at startup and filter out any matching models before analysis.
         """)
 
 if __name__ == "__main__":