Spaces:
Sleeping
Sleeping
File size: 7,761 Bytes
74dd3f1 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 |
import streamlit as st
import pandas as pd
from datetime import datetime
import difflib
import json
def fetch_model_versions(repo_id):
"""
Fetch model versions from the Hugging Face API.
In a real implementation, this would call the HF API to get version history.
For now, we'll use demo data.
"""
# In a production app, you would fetch this from the Hugging Face API
# For demo purposes, create some sample version data
versions = [
{
"version": "v1.0",
"commit_id": "abc123",
"timestamp": "2023-01-15T10:30:00Z",
"author": st.session_state.username,
"message": "Initial model release",
"files_changed": 5,
"performance": {"accuracy": 0.85, "f1": 0.82}
},
{
"version": "v1.1",
"commit_id": "def456",
"timestamp": "2023-02-20T14:45:00Z",
"author": st.session_state.username,
"message": "Improved tokenization",
"files_changed": 2,
"performance": {"accuracy": 0.87, "f1": 0.84}
},
{
"version": "v2.0",
"commit_id": "ghi789",
"timestamp": "2023-03-10T09:15:00Z",
"author": st.session_state.username,
"message": "Major model architecture upgrade",
"files_changed": 12,
"performance": {"accuracy": 0.92, "f1": 0.90}
}
]
return versions
def render_version_history(model_info):
"""Render the version history of a model"""
if not model_info:
st.error("Model information not found")
return
repo_id = model_info.modelId
st.subheader("🔄 Version History")
with st.spinner("Loading version history..."):
versions = fetch_model_versions(repo_id)
if not versions:
st.info("No version history found for this model.")
return
# Convert to DataFrame for easier display
df = pd.DataFrame(versions)
# Format timestamp
df["timestamp"] = pd.to_datetime(df["timestamp"]).dt.strftime("%Y-%m-%d %H:%M")
# Create a cleaner display version
display_df = df[["version", "timestamp", "author", "message", "files_changed"]]
display_df.columns = ["Version", "Date", "Author", "Commit Message", "Files Changed"]
# Show the version history
st.dataframe(display_df, use_container_width=True)
# Version comparison
st.subheader("Compare Versions")
col1, col2 = st.columns(2)
with col1:
base_version = st.selectbox(
"Base Version",
options=df["version"].tolist(),
index=0
)
with col2:
compare_version = st.selectbox(
"Compare Version",
options=[v for v in df["version"].tolist() if v != base_version],
index=0
)
if st.button("Compare", use_container_width=True):
with st.spinner("Generating comparison..."):
# In a real implementation, fetch the actual data from each version
# For demo, use the sample performance metrics
base_data = df[df["version"] == base_version].iloc[0]
compare_data = df[df["version"] == compare_version].iloc[0]
# Display comparison
col1, col2 = st.columns(2)
with col1:
st.markdown(f"### {base_version}")
st.markdown(f"**Commit:** {base_data['commit_id']}")
st.markdown(f"**Date:** {base_data['timestamp']}")
st.markdown(f"**Author:** {base_data['author']}")
st.markdown(f"**Message:** {base_data['message']}")
# Performance metrics
st.markdown("#### Performance Metrics")
for metric, value in base_data["performance"].items():
st.markdown(f"**{metric.capitalize()}:** {value:.4f}")
with col2:
st.markdown(f"### {compare_version}")
st.markdown(f"**Commit:** {compare_data['commit_id']}")
st.markdown(f"**Date:** {compare_data['timestamp']}")
st.markdown(f"**Author:** {compare_data['author']}")
st.markdown(f"**Message:** {compare_data['message']}")
# Performance metrics
st.markdown("#### Performance Metrics")
for metric, value in compare_data["performance"].items():
# Calculate change
base_value = base_data["performance"].get(metric, 0)
change = value - base_value
change_pct = (change / base_value * 100) if base_value != 0 else float('inf')
# Display with change indicator
if change > 0:
st.markdown(f"**{metric.capitalize()}:** {value:.4f} 📈 **(+{change:.4f}, {change_pct:.2f}%)**")
elif change < 0:
st.markdown(f"**{metric.capitalize()}:** {value:.4f} 📉 **({change:.4f}, {change_pct:.2f}%)**")
else:
st.markdown(f"**{metric.capitalize()}:** {value:.4f} (no change)")
# Show visual diff of model config
st.subheader("Configuration Changes")
# Sample configs (in a real app, you'd fetch these from the API)
base_config = {
"hidden_size": 768,
"num_attention_heads": 12,
"num_hidden_layers": 6,
"vocab_size": 30000
}
compare_config = {
"hidden_size": 1024,
"num_attention_heads": 16,
"num_hidden_layers": 8,
"vocab_size": 30000
}
# Generate a formatted diff
base_str = json.dumps(base_config, indent=2).splitlines()
compare_str = json.dumps(compare_config, indent=2).splitlines()
diff = difflib.unified_diff(
base_str,
compare_str,
fromfile=f'config_{base_version}',
tofile=f'config_{compare_version}',
lineterm=''
)
diff_html = []
for line in diff:
if line.startswith('+'):
diff_html.append(f'<span style="color: green">{line}</span>')
elif line.startswith('-'):
diff_html.append(f'<span style="color: red">{line}</span>')
elif line.startswith('@@'):
diff_html.append(f'<span style="color: purple">{line}</span>')
else:
diff_html.append(line)
st.markdown('<div style="background-color: #f5f5f5; padding: 10px; border-radius: 5px; font-family: monospace; white-space: pre-wrap;">' + '<br>'.join(diff_html) + '</div>', unsafe_allow_html=True)
# Rollback functionality
st.subheader("Rollback to Previous Version")
rollback_version = st.selectbox(
"Select version to rollback to",
options=df["version"].tolist(),
index=len(df)-2 # Default to second-to-last version
)
if st.button("Rollback", use_container_width=True, type="primary"):
with st.spinner("Rolling back to version " + rollback_version):
# In a real implementation, this would call the HF API to perform the rollback
st.success(f"Successfully rolled back to {rollback_version}")
# Here you would update the model information and refresh the view
|