store

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text

app_backup.py

@@ -0,0 +1,313 @@
+import gradio as gr
+import os
+import json
+from datetime import datetime
+from datasets import load_dataset
+import tempfile
+
+# 从Hugging Face dataset加载视频 / Load videos from Hugging Face dataset
+def load_videos_from_huggingface():
+    try:
+        dataset = load_dataset("WenjiaWang/videoforuser")
+        print("成功加载数据集: WenjiaWang/videoforuser / Successfully loaded dataset")
+        
+        # 获取数据集中的文件夹列表
+        question_folders = set()
+        all_videos = {}  # 存储所有视频路径 {folder: {method: video_path}}
+        
+        # 假设数据集包含file_path字段，或者使用标准的数据集结构
+        if 'train' in dataset:
+            for item in dataset['train']:
+                # 根据数据集的实际结构调整字段名
+                if 'file_path' in item:
+                    file_path = item['file_path']
+                elif 'path' in item:
+                    file_path = item['path']
+                elif 'video_path' in item:
+                    file_path = item['video_path']
+                else:
+                    continue
+                
+                # 从路径提取文件夹名和文件名
+                folder_name = os.path.basename(os.path.dirname(file_path))
+                file_name = os.path.basename(file_path)
+                
+                question_folders.add(folder_name)
+                
+                if folder_name not in all_videos:
+                    all_videos[folder_name] = {}
+                
+                # 确定方法名并映射到匿名显示名
+                display_name = f"Method {len(all_videos[folder_name]) + 1}"
+                all_videos[folder_name][display_name] = item
+        
+        return list(sorted(question_folders)), all_videos
+        
+    except Exception as e:
+        print(f"Hugging Face数据集加载失败: {e} / Hugging Face dataset loading failed")
+        print("回退到本地videos文件夹 / Falling back to local videos folder")
+        return None, None
+
+# 获取所有问题文件夹 / Get all question folders
+def get_question_folders():
+    # 优先使用Hugging Face数据集
+    hf_folders, hf_videos = load_videos_from_huggingface()
+    if hf_folders and hf_videos:
+        return hf_folders
+    
+    # 回退到本地文件夹
+    video_dir = "videos"
+    if not os.path.exists(video_dir):
+        print(f"视频目录不存在: {video_dir} / Video directory not found")
+        return []
+    
+    folders = [f for f in os.listdir(video_dir) if os.path.isdir(os.path.join(video_dir, f))]
+    return sorted(folders)
+
+# 获取问题文件夹中的所有视频 / Get all videos in the question folder
+def get_videos_for_question(question_folder):
+    # 优先使用Hugging Face数据集
+    hf_folders, hf_videos = load_videos_from_huggingface()
+    if hf_folders and hf_videos and question_folder in hf_videos:
+        videos = {}
+        method_mapping = {}
+        
+        for display_name, item in hf_videos[question_folder].items():
+            # 从item中获取视频路径或内容
+            if 'file_content' in item:
+                # 如果视频内容直接存储在数据集中
+                import tempfile
+                with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp:
+                    tmp.write(item['file_content'])
+                    videos[display_name] = tmp.name
+            elif 'file_path' in item:
+                # 如果存储的是路径
+                videos[display_name] = item['file_path']
+            elif 'path' in item:
+                videos[display_name] = item['path']
+            
+            # 创建方法映射（假设能从路径推断真实方法名）
+            if 'file_path' in item:
+                file_path = item['file_path']
+                if 'stage12_new' in file_path:
+                    method_mapping[display_name] = "Ours (stage12_new)"
+                elif 'gen3c' in file_path:
+                    method_mapping[display_name] = "Gen3c"
+                elif 'svc' in file_path:
+                    method_mapping[display_name] = "SVC"
+                elif 'trajattn' in file_path:
+                    method_mapping[display_name] = "TrajAttn"
+        
+        return videos, method_mapping
+    
+    # 回退到本地文件夹
+    video_dir = os.path.join("videos", question_folder)
+    videos = {}
+    method_mapping = {}  # 显示名称映射到真实方法名 / Map display names to real method names
+    
+    if os.path.exists(video_dir):
+        for file in os.listdir(video_dir):
+            if file.endswith('.mp4'):
+                video_path = os.path.join(video_dir, file)
+                # 确定方法名称 / Determine method name
+                if file.startswith('stage12_new'):
+                    real_method_name = "Ours (stage12_new)"
+                elif file.startswith('gen3c'):
+                    real_method_name = "Gen3c"
+                elif file.startswith('svc'):
+                    real_method_name = "SVC"
+                elif file.startswith('trajattn'):
+                    real_method_name = "TrajAttn"
+                else:
+                    real_method_name = file.replace('.mp4', '')
+                
+                # 使用匿名显示名称 / Use anonymous display names
+                display_name = f"Method {len(videos) + 1}"
+                videos[display_name] = video_path
+                method_mapping[display_name] = real_method_name
+    
+    return videos, method_mapping
+
+# 保存评分数据 / Save rating data
+def save_ratings(current_question, ratings_data, method_mapping):
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"ratings_{timestamp}.json"
+    
+    # 将显示名称映射到真实方法名 / Map display names to real method names
+    mapped_ratings = {}
+    for display_name, ratings in ratings_data.items():
+        real_method = method_mapping.get(display_name, display_name)
+        mapped_ratings[real_method] = ratings
+    
+    # 读取现有数据 / Read existing data
+    all_data = []
+    if os.path.exists("ratings_data.json"):
+        try:
+            with open("ratings_data.json", "r", encoding="utf-8") as f:
+                all_data = json.load(f)
+        except:
+            all_data = []
+    
+    # 添加新数据 / Add new data
+    entry = {
+        "timestamp": timestamp,
+        "question": current_question,
+        "ratings": mapped_ratings
+    }
+    all_data.append(entry)
+    
+    # 保存数据 / Save data
+    with open("ratings_data.json", "w", encoding="utf-8") as f:
+        json.dump(all_data, f, ensure_ascii=False, indent=2)
+    
+    return f"评分已保存到 {filename}"
+
+# 创建Gradio界面 / Create Gradio interface
+def create_video_survey_app():
+    question_folders = get_question_folders()
+    current_question_idx = gr.State(0)
+    all_ratings = gr.State({})
+    current_method_mapping = gr.State({})
+    
+    with gr.Blocks(title="视频生成质量用户研究") as demo:
+        gr.Markdown("# 视频生成质量用户研究 / Video Generation Quality User Study")
+        gr.Markdown("Please rate each video based on dynamic generation quality, static consistency, and overall quality. 对每个视频从动态生成能力、静态物体的一致性、整体质量三方面进行1~5的评分")
+        gr.Markdown("Rating scale: 1-5 (5 = Best) 评分等级：1-5分（5分为最好）")
+        
+        with gr.Row():
+            prev_btn = gr.Button("上一题 / Previous", visible=False)
+            question_text = gr.Markdown(f"问题 1 / {len(question_folders)} / Question 1 / {len(question_folders)}")
+            next_btn = gr.Button("下一题 / Next")
+        
+        # 视频显示区域 / Video display area
+        with gr.Row():
+            video_cols = []
+            method_display_names = ["Method 1", "Method 2", "Method 3", "Method 4"]
+            
+            for i, method in enumerate(method_display_names):
+                with gr.Column():
+                    gr.Markdown(f"### {method}")
+                    video = gr.Video(visible=False)
+                    video_cols.append(video)
+        
+        # 评分区域 / Rating area
+        with gr.Row():
+            ratings_cols = []
+            
+            for i, method in enumerate(method_display_names):
+                with gr.Column():
+                    gr.Markdown(f"#### {method} 评分 / Rating")
+                    
+                    dynamic_quality = gr.Slider(
+                        minimum=1, maximum=5, step=1, value=3,
+                        label="Dynamic Generation Quality / 动态生成能力"
+                    )
+                    static_consistency = gr.Slider(
+                        minimum=1, maximum=5, step=1, value=3,
+                        label="Static Consistency / 静态一致性"
+                    )
+                    overall_quality = gr.Slider(
+                        minimum=1, maximum=5, step=1, value=3,
+                        label="Overall Quality / 整体质量"
+                    )
+                    
+                    ratings_cols.append({
+                        "dynamic_quality": dynamic_quality,
+                        "static_consistency": static_consistency,
+                        "overall_quality": overall_quality
+                    })
+        
+        status_text = gr.Textbox(label="状态 / Status", interactive=False)
+        
+        # 更新问题显示的函数 / Function to update question display
+        def update_question(question_idx):
+            if question_idx < 0 or question_idx >= len(question_folders):
+                return []
+            
+            question_folder = question_folders[question_idx]
+            videos, method_mapping = get_videos_for_question(question_folder)
+            
+            video_outputs = []
+            method_display_names = ["Method 1", "Method 2", "Method 3", "Method 4"]
+            
+            for method_display in method_display_names:
+                if method_display in videos:
+                    video_outputs.append(gr.Video(value=videos[method_display], visible=True))
+                else:
+                    video_outputs.append(gr.Video(visible=False))
+            
+            question_markdown = f"问题 {question_idx + 1} / {len(question_folders)}: {question_folder} / Question {question_idx + 1} / {len(question_folders)}: {question_folder}"
+            
+            return video_outputs + [gr.Markdown(question_markdown)] + [gr.State(value=method_mapping)]
+        
+        # 保存当前评分的函数 / Function to save current ratings
+        def save_current_ratings(question_idx, method_mapping, *rating_values):
+            if question_idx >= len(question_folders):
+                return "没有更多问题了 / No more questions"
+            
+            question_folder = question_folders[question_idx]
+            method_display_names = ["Method 1", "Method 2", "Method 3", "Method 4"]
+            
+            ratings = {}
+            for i, method_display in enumerate(method_display_names):
+                base_idx = i * 3
+                ratings[method_display] = {
+                    "dynamic_quality": rating_values[base_idx],
+                    "static_consistency": rating_values[base_idx + 1],
+                    "overall_quality": rating_values[base_idx + 2]
+                }
+            
+            return save_ratings(question_folder, ratings, method_mapping)
+        
+        # 事件处理 / Event handling
+        def on_next_click(question_idx, method_mapping, *rating_values):
+            # 先保存当前评分 / First save current ratings
+            save_message = save_current_ratings(question_idx, method_mapping, *rating_values)
+            
+            # 移动到下一题 / Move to next question
+            new_idx = question_idx + 1
+            if new_idx >= len(question_folders):
+                return [save_message + "\n所有问题已完成！/ All questions completed!"] + [gr.Button(visible=False)] * 3
+            
+            # 更新显示 / Update display
+            video_updates = update_question(new_idx)
+            
+            return [save_message + f"\n当前问题: {question_folders[new_idx]}/ Current question: {question_folders[new_idx]}"] + video_updates
+        
+        def on_prev_click(question_idx):
+            new_idx = question_idx - 1
+            if new_idx < 0:
+                return []
+            
+            return update_question(new_idx)
+        
+        # 收集所有评分组件
+        all_rating_components = []
+        for col in ratings_cols:
+            all_rating_components.extend([
+                col["dynamic_quality"],
+                col["static_consistency"],
+                col["overall_quality"]
+            ])
+        
+        # 初始化第一个问题
+        initial_videos = update_question(0)
+        
+        # 绑定事件 / Bind events
+        next_btn.click(
+            on_next_click,
+            inputs=[current_question_idx, current_method_mapping] + all_rating_components,
+            outputs=[status_text] + video_cols + [question_text] + [current_method_mapping]
+        )
+        
+        prev_btn.click(
+            on_prev_click,
+            inputs=[current_question_idx],
+            outputs=video_cols + [question_text] + [current_method_mapping]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    app = create_video_survey_app()
+    app.launch(share=True)

app_fixed.py

@@ -0,0 +1,334 @@
+import gradio as gr
+import os
+import json
+from datetime import datetime
+from datasets import load_dataset
+import random
+
+# 全局变量存储数据集
+DATASET = None
+VIDEO_DATA = None
+
+# 从Hugging Face dataset加载视频
+def load_videos_from_huggingface():
+    global DATASET, VIDEO_DATA
+    
+    try:
+        print("正在加载数据集: WenjiaWang/videoforuser...")
+        DATASET = load_dataset("WenjiaWang/videoforuser", split="train")
+        print(f"成功加载数据集，共 {len(DATASET)} 个视频")
+        
+        # 组织视频数据：按场景分组
+        VIDEO_DATA = {}
+        
+        for idx, item in enumerate(DATASET):
+            # 获取视频路径信息
+            if 'video' in item:
+                video_path = item['video']
+            elif 'path' in item:
+                video_path = item['path']
+            else:
+                print(f"警告: 第 {idx} 项没有视频路径字段")
+                continue
+            
+            # 从路径中提取场景名和方法名
+            # 假设路径格式类似: "videos/scene_name/method.mp4"
+            path_parts = video_path.split('/')
+            if len(path_parts) >= 2:
+                scene_name = path_parts[-2]  # 倒数第二部分是场景名
+                file_name = path_parts[-1]    # 最后部分是文件名
+                
+                # 提取方法名
+                method_name = file_name.replace('.mp4', '')
+                
+                if scene_name not in VIDEO_DATA:
+                    VIDEO_DATA[scene_name] = {}
+                
+                # 存储视频信息（包括在dataset中的索引）
+                VIDEO_DATA[scene_name][method_name] = {
+                    'index': idx,
+                    'path': video_path,
+                    'item': item
+                }
+        
+        print(f"组织完成，共 {len(VIDEO_DATA)} 个场景")
+        return True
+        
+    except Exception as e:
+        print(f"加载数据集失败: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+# 获取所有场景列表
+def get_question_folders():
+    if VIDEO_DATA is None:
+        success = load_videos_from_huggingface()
+        if not success:
+            return []
+    
+    return sorted(list(VIDEO_DATA.keys()))
+
+# 获取某个场景的所有视频
+def get_videos_for_question(scene_name):
+    if VIDEO_DATA is None or scene_name not in VIDEO_DATA:
+        return {}, {}
+    
+    scene_videos = VIDEO_DATA[scene_name]
+    
+    # 创建方法名到真实名称的映射
+    method_names = list(scene_videos.keys())
+    
+    # 随机打乱顺序以匿名化
+    shuffled_methods = method_names.copy()
+    random.shuffle(shuffled_methods)
+    
+    videos = {}
+    method_mapping = {}
+    
+    for i, method_name in enumerate(shuffled_methods):
+        display_name = f"Method {chr(65+i)}"  # Method A, B, C, D
+        
+        # 获取视频数据
+        video_info = scene_videos[method_name]
+        video_item = video_info['item']
+        
+        # 从dataset item中获取视频文件
+        if 'video' in video_item:
+            videos[display_name] = video_item['video']  # 这应该是视频文件路径或对象
+        
+        method_mapping[display_name] = method_name
+    
+    return videos, method_mapping
+
+# 保存评分数据
+def save_ratings(scene_name, ratings_data, method_mapping):
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    # 将显示名称映射到真实方法名
+    mapped_ratings = {}
+    for display_name, ratings in ratings_data.items():
+        real_method = method_mapping.get(display_name, display_name)
+        mapped_ratings[real_method] = ratings
+    
+    # 读取现有数据
+    all_data = []
+    if os.path.exists("ratings_data.json"):
+        try:
+            with open("ratings_data.json", "r", encoding="utf-8") as f:
+                all_data = json.load(f)
+        except:
+            all_data = []
+    
+    # 添加新数据
+    entry = {
+        "timestamp": timestamp,
+        "scene": scene_name,
+        "ratings": mapped_ratings
+    }
+    all_data.append(entry)
+    
+    # 保存数据
+    with open("ratings_data.json", "w", encoding="utf-8") as f:
+        json.dump(all_data, f, ensure_ascii=False, indent=2)
+    
+    return f"✓ 评分已保存 / Ratings saved"
+
+# 创建Gradio界面
+def create_video_survey_app():
+    # 预加载数据集
+    print("初始化应用...")
+    load_videos_from_huggingface()
+    question_folders = get_question_folders()
+    
+    if not question_folders:
+        print("错误: 没有找到任何场景数据")
+        return None
+    
+    print(f"找到 {len(question_folders)} 个场景")
+    
+    with gr.Blocks(title="视频生成质量用户研究", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🎬 视频生成质量用户研究 / Video Generation Quality User Study")
+        gr.Markdown("""
+        ### 说明 / Instructions:
+        - ��观看每个视频并进行评分 / Please watch each video and rate them
+        - 评分标准 / Rating criteria:
+          - **动态生成质量** / Dynamic Generation Quality: 视频中物体运动的流畅性和真实性
+          - **静态一致性** / Static Consistency: 视频中静态物体的稳定性和一致性
+          - **整体质量** / Overall Quality: 视频的整体观感
+        - 评分范围：1-5分（5分最好）/ Rating scale: 1-5 (5 = Best)
+        """)
+        
+        # 状态变量
+        current_question_idx = gr.State(0)
+        current_method_mapping = gr.State({})
+        
+        # 进度显示
+        with gr.Row():
+            prev_btn = gr.Button("⬅️ 上一题 / Previous", size="sm")
+            question_text = gr.Markdown(f"**场景 1 / {len(question_folders)}**")
+            next_btn = gr.Button("下一题 / Next ➡️", size="sm", variant="primary")
+        
+        status_text = gr.Textbox(label="状态 / Status", interactive=False, visible=False)
+        
+        # 视频显示区域（4个视频）
+        video_components = []
+        rating_components = []
+        
+        for i in range(4):
+            method_name = f"Method {chr(65+i)}"
+            
+            with gr.Group():
+                gr.Markdown(f"### 🎥 {method_name}")
+                
+                video = gr.Video(label="", height=300)
+                video_components.append(video)
+                
+                with gr.Row():
+                    dynamic = gr.Slider(
+                        minimum=1, maximum=5, step=1, value=3,
+                        label="动态质量 / Dynamic Quality",
+                        info="1=差 / Poor, 5=优秀 / Excellent"
+                    )
+                    static = gr.Slider(
+                        minimum=1, maximum=5, step=1, value=3,
+                        label="静态一致性 / Static Consistency",
+                        info="1=差 / Poor, 5=优秀 / Excellent"
+                    )
+                    overall = gr.Slider(
+                        minimum=1, maximum=5, step=1, value=3,
+                        label="整体质量 / Overall Quality",
+                        info="1=差 / Poor, 5=优秀 / Excellent"
+                    )
+                
+                rating_components.append({
+                    "dynamic": dynamic,
+                    "static": static,
+                    "overall": overall
+                })
+        
+        # 更新问题显示
+        def update_question(question_idx, save_previous=False, prev_ratings=None, prev_mapping=None):
+            if question_idx < 0:
+                question_idx = 0
+            if question_idx >= len(question_folders):
+                question_idx = len(question_folders) - 1
+            
+            # 如果需要，保存上一题的评分
+            save_msg = ""
+            if save_previous and prev_ratings and prev_mapping:
+                prev_scene = question_folders[question_idx - 1] if question_idx > 0 else None
+                if prev_scene:
+                    save_msg = save_ratings(prev_scene, prev_ratings, prev_mapping)
+            
+            scene_name = question_folders[question_idx]
+            videos, method_mapping = get_videos_for_question(scene_name)
+            
+            # 更新视频显示
+            video_updates = []
+            for i in range(4):
+                method_name = f"Method {chr(65+i)}"
+                if method_name in videos:
+                    video_updates.append(gr.Video(value=videos[method_name], visible=True))
+                else:
+                    video_updates.append(gr.Video(value=None, visible=False))
+            
+            # 重置评分
+            rating_updates = [gr.Slider(value=3) for _ in range(12)]  # 4个视频 x 3个评分
+            
+            question_markdown = f"**场景 {question_idx + 1} / {len(question_folders)}**: `{scene_name}`"
+            
+            return (
+                [question_idx, method_mapping, question_markdown, save_msg] +
+                video_updates +
+                rating_updates
+            )
+        
+        # 收集当前评分
+        def collect_ratings(*rating_values):
+            ratings = {}
+            for i in range(4):
+                method_name = f"Method {chr(65+i)}"
+                base_idx = i * 3
+                ratings[method_name] = {
+                    "dynamic_quality": rating_values[base_idx],
+                    "static_consistency": rating_values[base_idx + 1],
+                    "overall_quality": rating_values[base_idx + 2]
+                }
+            return ratings
+        
+        # 下一题按钮
+        def on_next(question_idx, method_mapping, *rating_values):
+            # 收集当前评分
+            current_ratings = collect_ratings(*rating_values)
+            
+            # 保存当前评分
+            scene_name = question_folders[question_idx]
+            save_msg = save_ratings(scene_name, current_ratings, method_mapping)
+            
+            # 移动到下一题
+            new_idx = question_idx + 1
+            if new_idx >= len(question_folders):
+                return [
+                    question_idx,
+                    method_mapping,
+                    f"**✅ 所有场景已完成！/ All scenes completed!**",
+                    save_msg + "\n🎉 感谢参与！/ Thank you for participating!"
+                ] + [gr.Video()] * 4 + [gr.Slider(value=3)] * 12
+            
+            return update_question(new_idx)
+        
+        # 上一题按钮
+        def on_prev(question_idx, *args):
+            new_idx = question_idx - 1
+            if new_idx < 0:
+                new_idx = 0
+            return update_question(new_idx)
+        
+        # 收集所有评分组件
+        all_rating_inputs = []
+        for comp in rating_components:
+            all_rating_inputs.extend([comp["dynamic"], comp["static"], comp["overall"]])
+        
+        # 绑定事件
+        next_btn.click(
+            on_next,
+            inputs=[current_question_idx, current_method_mapping] + all_rating_inputs,
+            outputs=[
+                current_question_idx,
+                current_method_mapping,
+                question_text,
+                status_text
+            ] + video_components + all_rating_inputs
+        )
+        
+        prev_btn.click(
+            on_prev,
+            inputs=[current_question_idx] + all_rating_inputs,
+            outputs=[
+                current_question_idx,
+                current_method_mapping,
+                question_text,
+                status_text
+            ] + video_components + all_rating_inputs
+        )
+        
+        # 初始化第一个问题
+        demo.load(
+            lambda: update_question(0),
+            outputs=[
+                current_question_idx,
+                current_method_mapping,
+                question_text,
+                status_text
+            ] + video_components + all_rating_inputs
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    app = create_video_survey_app()
+    if app:
+        app.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    else:
+        print("应用初始化失败 / App initialization failed")

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=4.0.0
+datasets>=2.14.0
+huggingface_hub>=0.19.0
+torchcodec

upload_to_hf.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+上传文件到 Hugging Face Space
+"""
+from huggingface_hub import HfApi, login
+import os
+
+# 你需要在这里输入你的 Hugging Face token
+# 获取 token: https://huggingface.co/settings/tokens
+TOKEN = input("请输入你的 Hugging Face token: ").strip()
+
+if not TOKEN:
+    print("❌ 错误: 需要提供 token")
+    print("请访问 https://huggingface.co/settings/tokens 获取 token")
+    exit(1)
+
+# 登录
+print("正在登录...")
+login(token=TOKEN)
+
+# 初始化 API
+api = HfApi()
+
+# Space 信息
+repo_id = "WenjiaWang/userstudy"
+repo_type = "space"
+
+print(f"\n📤 准备上传文件到 {repo_id}...")
+
+# 要上传的文件
+files_to_upload = [
+    "app.py",
+    "requirements.txt",
+]
+
+# 上传每个文件
+for file_name in files_to_upload:
+    if os.path.exists(file_name):
+        print(f"  ⬆️  上传 {file_name}...")
+        try:
+            api.upload_file(
+                path_or_fileobj=file_name,
+                path_in_repo=file_name,
+                repo_id=repo_id,
+                repo_type=repo_type,
+                commit_message=f"Upload {file_name}"
+            )
+            print(f"  ✅ {file_name} 上传成功")
+        except Exception as e:
+            print(f"  ❌ {file_name} 上传失败: {e}")
+    else:
+        print(f"  ⚠️  文件不存在: {file_name}")
+
+print(f"\n🎉 完成！请访问: https://huggingface.co/spaces/{repo_id}")
+print("Space 会自动构建和启动，可能需要几分钟时间。")