update sth. at 2024-11-15 18:31:06

app.py

@@ -2,165 +2,107 @@ import gradio as gr
 from huggingface_hub import InferenceClient
 from PIL import Image
 import requests
-from bs4 import BeautifulSoup
-import json
-import uuid
+import os
 
 # ===================== 核心逻辑模块 =====================
 
 # 初始化所需的模型客户端
-client_gemma = InferenceClient("mistralai/Mistral-7B-Instruct-v0.3")
-client_mixtral = InferenceClient("NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO")
-client_llama = InferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
-client_yi = InferenceClient("01-ai/Yi-1.5-34B-Chat")
+try:
+    # 文本聊天模型
+    client_text = InferenceClient("meta-llama/Llama-3.2-11B-Vision-Instruct")
+    
+    # 图片生成模型
+    client_image = InferenceClient("black-forest-labs/FLUX.1-dev")
+    
+    # 图像问答模型
+    client_vqa = InferenceClient()
+except Exception as e:
+    print(f"Error initializing clients: {e}")
 
+# ---------- 文本聊天模块 ----------
 
-# ---------- 服务状态检查模块 ----------
-
-def check_service_status():
-    """
-    检查各个服务的可用状态，返回服务状态字典。
+def chat_with_model(messages):
     """
-    services = {
-        "Gemma": check_inference_client(client_gemma),
-        "Mixtral": check_inference_client(client_mixtral),
-        "Llama": check_inference_client(client_llama),
-        "Yi": check_inference_client(client_yi),
-    }
-    return services
-
-def check_inference_client(client):
-    """
-    尝试发送简单请求以检查服务的可用性。
+    调用文本聊天模型生成对话内容。
     """
     try:
-        # 发送一个简单的预测请求以验证可用性，使用空文本预测请求
-        response = client.predict({"inputs": ""})
-        return True if response else False
-    except Exception:
-        return False
-
-def get_service_status_markdown():
-    """
-    格式化服务状态为 Markdown 文本，用于界面展示。
-    """
-    statuses = check_service_status()
-    status_text = "\n".join([f"{service}: {'🟢 可用' if available else '🔴 不可用'}" for service, available in statuses.items()])
-    return status_text  # 返回字符串而不是 gr.Markdown 对象
-
+        response = client_text.chat_completion(messages, max_tokens=100)
+        return response["choices"][0]["message"]["content"]
+    except Exception as e:
+        print(f"Chat generation failed: {e}")
+        return "聊天生成失败，请稍后再试。"
 
 # ---------- 图像生成模块 ----------
 
 def image_gen(prompt):
     """
-    调用图像生成模型生成图像，返回生成的图像路径。
-    """
-    client = InferenceClient("KingNish/Image-Gen-Pro")
-    response = client.predict("Image Generation", None, prompt, api_name="/image_gen_pro")
-    image = response.get("image")  # 假设返回的结果包含图像
-    return image
-
-
-# ---------- 文本和图像问答模块 ----------
-
-def process_llava_input(message, history, processor):
-    """
-    处理 LLaVA 图像问答输入，提取文本与图像输入，生成模型输入。
-    """
-    image = None
-    if message["files"]:
-        image = message["files"][0]  # 如果有上传的图像文件
-    else:
-        for hist in history:
-            if isinstance(hist[0], tuple):
-                image = hist[0][0]  # 从历史记录中提取最后一个图像
-
-    txt = message["text"]
-    image = Image.open(image).convert("RGB")
-    prompt = f"<|im_start|>user <image>\n{txt}<|im_end|><|im_start|>assistant"
-    inputs = processor(prompt, image, return_tensors="pt")
-    return inputs
-
-
-def llava_answer(inputs, model):
+    调用图像生成模型生成图像。
     """
-    调用 LLaVA 模型回答图像问答请求，返回回答结果。
-    """
-    # 使用模型生成回答的逻辑
-    output = model.generate(**inputs)
-    answer = output[0]["generated_text"]  # 假设模型返回文本在 `generated_text` 字段
-    return answer
-
+    try:
+        image = client_image.text_to_image(prompt)
+        return image
+    except Exception as e:
+        print(f"Image generation failed: {e}")
+        return None
 
-# ---------- 网络搜索模块 ----------
+# ---------- 图像问答模块 ----------
 
-def search(query):
-    """
-    执行网络搜索，返回搜索结果标题和链接。
+def visual_qa(image, question):
     """
-    search_results = []
-    with requests.Session() as session:
-        resp = session.get("https://www.google.com/search", params={"q": query, "num": 3})
-        soup = BeautifulSoup(resp.text, "html.parser")
-        
-        # 提取搜索结果的标题和链接
-        for item in soup.select('div.g'):
-            title_element = item.select_one("h3")
-            link_element = item.select_one("a")
-            if title_element and link_element:
-                title = title_element.get_text()
-                link = link_element["href"]
-                search_results.append((title, link))
-    return search_results
-
-
-# ---------- 回答生成模块 ----------
-
-def respond(message, history, client):
+    调用视觉文档问答模型回答图像问题。
     """
-    根据输入的消息和历史记录，选择合适的模型生成回答。
-    """
-    # 使用指定的模型 client 来生成回答
-    response = client.predict({"inputs": message})
-    answer = response.get("generated_text")  # 假设返回结果包含生成的文本
-    return answer
-
+    try:
+        # 如果输入是路径或URL，则直接加载
+        if isinstance(image, str):
+            response = client_vqa.visual_question_answering(image=image, question=question)
+        else:
+            # 将本地图像保存为临时文件以供模型使用
+            temp_image_path = f"/tmp/{os.path.basename(image.filename)}"
+            image.save(temp_image_path)
+            response = client_vqa.visual_question_answering(image=temp_image_path, question=question)
+        return response["answer"]
+    except Exception as e:
+        print(f"Visual QA failed: {e}")
+        return "图像问答失败，请稍后再试。"
 
 # ===================== Gradio 界面构建 =====================
 
 def build_interface():
     """
-    构建 Gradio 界面布局，包括服务状态栏、文本聊天、图像生成和图像问答选项卡。
+    构建 Gradio 界面布局，包括文本聊天、图像生成和图像问答选项卡。
     """
     with gr.Blocks() as demo:
-        # 服务状态栏
-        gr.Markdown("# 服务状态")
-        gr.Markdown(get_service_status_markdown())  # 直接传入字符串
-
-        # 多模态交互主界面
+        # 文本聊天
         with gr.Tab("文本聊天"):
-            chat_textbox = gr.Textbox(label="输入你的问题", placeholder="输入文本...")
-            chat_output = gr.Chatbot()
-            chat_button = gr.Button("发送")
+            chatbox_input = gr.Textbox(label="输入你的问题", placeholder="请提问...")
+            chatbox_output = gr.Textbox(label="回答")
+            chatbox_button = gr.Button("发送")
+
+            def chat_handler(user_input):
+                messages = [{"role": "user", "content": user_input}]
+                return chat_with_model(messages)
+
+            chatbox_button.click(chat_handler, inputs=chatbox_input, outputs=chatbox_output)
 
+        # 图像生成
         with gr.Tab("图像生成"):
-            image_prompt = gr.Textbox(label="图像提示词", placeholder="输入描述来生成图像")
-            image_output = gr.Image()
+            image_prompt = gr.Textbox(label="图像提示词", placeholder="描述你想生成的图像")
+            image_output = gr.Image(label="生成的图像")
             image_button = gr.Button("生成图像")
 
+            image_button.click(image_gen, inputs=image_prompt, outputs=image_output)
+
+        # 图像问答
         with gr.Tab("图像问答"):
-            image_upload = gr.Image(label="上传图像")
-            image_question = gr.Textbox(label="提问", placeholder="输入关于图像的问题")
-            answer_output = gr.Textbox(label="回答")
-            answer_button = gr.Button("回答")
-
-        # 各个按钮的点击事件
-        chat_button.click(lambda msg, hist: respond(msg, hist, client_gemma), inputs=[chat_textbox, chat_output], outputs=chat_output)
-        image_button.click(image_gen, inputs=image_prompt, outputs=image_output)
-        answer_button.click(lambda msg, hist: llava_answer(process_llava_input(msg, hist, processor)), inputs=[image_upload, image_question], outputs=answer_output)
-
-        gr.Markdown("### 说明")
-        gr.Markdown("该助手支持文本聊天、图像生成和图像问答等功能。根据不同需求选择对应的选项卡使用。")
+            vqa_image = gr.Image(label="上传图像")
+            vqa_question = gr.Textbox(label="问题", placeholder="输入关于图像的问题")
+            vqa_output = gr.Textbox(label="回答")
+            vqa_button = gr.Button("回答")
+
+            vqa_button.click(visual_qa, inputs=[vqa_image, vqa_question], outputs=vqa_output)
+
+        gr.Markdown("### 使用说明")
+        gr.Markdown("本助手支持文本聊天、图像生成和图像问答功能，使用上方选项卡切换不同功能。")
 
     return demo
 

app.py_v1

@@ -0,0 +1,170 @@
+import gradio as gr
+from huggingface_hub import InferenceClient
+from PIL import Image
+import requests
+from bs4 import BeautifulSoup
+import json
+import uuid
+
+# ===================== 核心逻辑模块 =====================
+
+# 初始化所需的模型客户端
+client_gemma = InferenceClient("mistralai/Mistral-7B-Instruct-v0.3")
+client_mixtral = InferenceClient("NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO")
+client_llama = InferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
+client_yi = InferenceClient("01-ai/Yi-1.5-34B-Chat")
+
+
+# ---------- 服务状态检查模块 ----------
+
+def check_service_status():
+    """
+    检查各个服务的可用状态，返回服务状态字典。
+    """
+    services = {
+        "Gemma": check_inference_client(client_gemma),
+        "Mixtral": check_inference_client(client_mixtral),
+        "Llama": check_inference_client(client_llama),
+        "Yi": check_inference_client(client_yi),
+    }
+    return services
+
+def check_inference_client(client):
+    """
+    尝试发送简单请求以检查服务的可用性。
+    """
+    try:
+        # 发送一个简单的预测请求以验证可用性，使用空文本预测请求
+        response = client.predict({"inputs": ""})
+        return True if response else False
+    except Exception:
+        return False
+
+def get_service_status_markdown():
+    """
+    格式化服务状态为 Markdown 文本，用于界面展示。
+    """
+    statuses = check_service_status()
+    status_text = "\n".join([f"{service}: {'🟢 可用' if available else '🔴 不可用'}" for service, available in statuses.items()])
+    return status_text  # 返回字符串而不是 gr.Markdown 对象
+
+
+# ---------- 图像生成模块 ----------
+
+def image_gen(prompt):
+    """
+    调用图像生成模型生成图像，返回生成的图像路径。
+    """
+    client = InferenceClient("KingNish/Image-Gen-Pro")
+    response = client.predict("Image Generation", None, prompt, api_name="/image_gen_pro")
+    image = response.get("image")  # 假设返回的结果包含图像
+    return image
+
+
+# ---------- 文本和图像问答模块 ----------
+
+def process_llava_input(message, history, processor):
+    """
+    处理 LLaVA 图像问答输入，提取文本与图像输入，生成模型输入。
+    """
+    image = None
+    if message["files"]:
+        image = message["files"][0]  # 如果有上传的图像文件
+    else:
+        for hist in history:
+            if isinstance(hist[0], tuple):
+                image = hist[0][0]  # 从历史记录中提取最后一个图像
+
+    txt = message["text"]
+    image = Image.open(image).convert("RGB")
+    prompt = f"<|im_start|>user <image>\n{txt}<|im_end|><|im_start|>assistant"
+    inputs = processor(prompt, image, return_tensors="pt")
+    return inputs
+
+
+def llava_answer(inputs, model):
+    """
+    调用 LLaVA 模型回答图像问答请求，返回回答结果。
+    """
+    # 使用模型生成回答的逻辑
+    output = model.generate(**inputs)
+    answer = output[0]["generated_text"]  # 假设模型返回文本在 `generated_text` 字段
+    return answer
+
+
+# ---------- 网络搜索模块 ----------
+
+def search(query):
+    """
+    执行网络搜索，返回搜索结果标题和链接。
+    """
+    search_results = []
+    with requests.Session() as session:
+        resp = session.get("https://www.google.com/search", params={"q": query, "num": 3})
+        soup = BeautifulSoup(resp.text, "html.parser")
+        
+        # 提取搜索结果的标题和链接
+        for item in soup.select('div.g'):
+            title_element = item.select_one("h3")
+            link_element = item.select_one("a")
+            if title_element and link_element:
+                title = title_element.get_text()
+                link = link_element["href"]
+                search_results.append((title, link))
+    return search_results
+
+
+# ---------- 回答生成模块 ----------
+
+def respond(message, history, client):
+    """
+    根据输入的消息和历史记录，选择合适的模型生成回答。
+    """
+    # 使用指定的模型 client 来生成回答
+    response = client.predict({"inputs": message})
+    answer = response.get("generated_text")  # 假设返回结果包含生成的文本
+    return answer
+
+
+# ===================== Gradio 界面构建 =====================
+
+def build_interface():
+    """
+    构建 Gradio 界面布局，包括服务状态栏、文本聊天、图像生成和图像问答选项卡。
+    """
+    with gr.Blocks() as demo:
+        # 服务状态栏
+        gr.Markdown("# 服务状态")
+        gr.Markdown(get_service_status_markdown())  # 直接传入字符串
+
+        # 多模态交互主界面
+        with gr.Tab("文本聊天"):
+            chat_textbox = gr.Textbox(label="输入你的问题", placeholder="输入文本...")
+            chat_output = gr.Chatbot()
+            chat_button = gr.Button("发送")
+
+        with gr.Tab("图像生成"):
+            image_prompt = gr.Textbox(label="图像提示词", placeholder="输入描述来生成图像")
+            image_output = gr.Image()
+            image_button = gr.Button("生成图像")
+
+        with gr.Tab("图像问答"):
+            image_upload = gr.Image(label="上传图像")
+            image_question = gr.Textbox(label="提问", placeholder="输入关于图像的问题")
+            answer_output = gr.Textbox(label="回答")
+            answer_button = gr.Button("回答")
+
+        # 各个按钮的点击事件
+        chat_button.click(lambda msg, hist: respond(msg, hist, client_gemma), inputs=[chat_textbox, chat_output], outputs=chat_output)
+        image_button.click(image_gen, inputs=image_prompt, outputs=image_output)
+        answer_button.click(lambda msg, hist: llava_answer(process_llava_input(msg, hist, processor)), inputs=[image_upload, image_question], outputs=answer_output)
+
+        gr.Markdown("### 说明")
+        gr.Markdown("该助手支持文本聊天、图像生成和图像问答等功能。根据不同需求选择对应的选项卡使用。")
+
+    return demo
+
+# 启动 Gradio 界面
+if __name__ == "__main__":
+    demo = build_interface()
+    demo.launch()

支持类型.md

@@ -0,0 +1,98 @@
+# hf的功能
+## 文字
+https://huggingface.co/docs/huggingface_hub/main/en/guides/inference#run-inference-on-servers
+
+from huggingface_hub import InferenceClient
+messages = [{"role": "user", "content": "中国的首都是哪里?"}]
+client = InferenceClient("meta-llama/Llama-3.2-11B-Vision-Instruct")
+client.chat_completion(messages, max_tokens=100)
+
+## 图片
+> 中文识别不好
+
+from huggingface_hub import InferenceClient
+client = InferenceClient()
+image = client.text_to_image("An astronaut riding a horse on the moon.")
+image.save("/Users/sanbo/Desktop/astronaut.png")  # 'image' is a PIL.Image object
+
+
+
+from huggingface_hub import InferenceClient
+client = InferenceClient("black-forest-labs/FLUX.1-dev")
+image = client.text_to_image("一个天上飞的乌龟.")
+image.save("/Users/sanbo/Desktop/astronaut.png")  # 'image' is a PIL.Image object
+
+## 视觉问答visual_question_answering
+
+from huggingface_hub import InferenceClient
+client = InferenceClient()
+client.visual_question_answering(
+    image="https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg",
+    question="What is the animal doing?"
+)
+
+## 翻译
+from huggingface_hub import InferenceClient
+client = InferenceClient()
+client.translation("My name is Wolfgang and I live in Berlin")
+'Mein Name ist Wolfgang und ich lebe in Berlin.'
+client.translation("My name is Wolfgang and I live in Berlin", model="Helsinki-NLP/opus-mt-en-zh")
+
+###  使用特定模型
+client = InferenceClient(model="prompthero/openjourney-v4")
+client.text_to_image("xxx")
+
+方式二
+client = InferenceClient()
+client.text_to_image(..., model="prompthero/openjourney-v4")
+
+
+## 客户端请求
+
+from huggingface_hub import InferenceClient
+client = InferenceClient()
+response = client.post(json={"inputs": "An astronaut riding a horse on the moon."}, model="stabilityai/stable-diffusion-2-1")
+response.content
+
+## 支持模型
+https://huggingface.co/models?other=conversational&sort=likes
+
+client = InferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
+client = InferenceClient("Qwen/Qwen2.5-Coder-32B-Instruct")
+
+
+## 支持任务
+
+
+|     域     |                                     任务                                      | 支持  | 文件                                                                                                                                                                                        |
+| :--------: | :---------------------------------------------------------------------------: | :---: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|    音频    |         [音频分类](https://huggingface.co/tasks/audio-classification)         |   ✅   | [audio_classification（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.audio_classification)                     |
+|    音频    |           [音频到音频](https://huggingface.co/tasks/audio-to-audio)           |   ✅   | [audio_to_audio（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.audio_to_audio)                                 |
+|            |   [自动语音识别](https://huggingface.co/tasks/automatic-speech-recognition)   |   ✅   | [自动语音识别](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.automatic_speech_recognition)                         |
+|            |         [Text-to-Speech](https://huggingface.co/tasks/text-to-speech)         |   ✅   | [text_to_speech（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.text_to_speech)                                 |
+| 计算机视觉 |         [图像分类](https://huggingface.co/tasks/image-classification)         |   ✅   | [image_classification（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.image_classification)                     |
+|            |          [图像分割](https://huggingface.co/tasks/image-segmentation)          |   ✅   | [image_segmentation（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.image_segmentation)                         |
+|            |         [Image-to-Image](https://huggingface.co/tasks/image-to-image)         |   ✅   | [image_to_image（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.image_to_image)                                 |
+|            |           [图像到文本](https://huggingface.co/tasks/image-to-text)            |   ✅   | [image_to_text（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.image_to_text)                                   |
+|            |           [对象检测](https://huggingface.co/tasks/object-detection)           |   ✅   | [object_detection（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.object_detection)                             |
+|            |           [文字转影像](https://huggingface.co/tasks/text-to-image)            |   ✅   | [text_to_image（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.text_to_image)                                   |
+|            | [零拍摄图像分类](https://huggingface.co/tasks/zero-shot-image-classification) |   ✅   | [zero_shot_image_classification（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.zero_shot_image_classification) |
+|    多式    |   [文档问题存档](https://huggingface.co/tasks/document-question-answering)    |   ✅   | [document_question_answering（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.document_question_answering)       |
+|            |    [视觉问题回答](https://huggingface.co/tasks/visual-question-answering)     |   ✅   | [visual_question_answering（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.visual_question_answering)           |
+|    NLP     |                                     会话                                      |       | 已弃用，请使用聊天完成                                                                                                                                                                      |
+|            |           [聊天完成](https://huggingface.co/tasks/text-generation)            |   ✅   | [chat_completion（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.chat_completion)                               |
+|            |          [特征提取](https://huggingface.co/tasks/feature-extraction)          |   ✅   | [feature_extraction（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.feature_extraction)                         |
+|            |              [填充掩膜](https://huggingface.co/tasks/fill-mask)               |   ✅   | [fill_mask（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.fill_mask)                                           |
+|            |            [问答](https://huggingface.co/tasks/question-answering)            |   ✅   | [question_answering（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.question_answering)                         |
+|            |        [句子相似度](https://huggingface.co/tasks/sentence-similarity)         |   ✅   | [sentence_similarity（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.sentence_similarity)                       |
+|            |              [总结](https://huggingface.co/tasks/summarization)               |   ✅   | [summarizing（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.summarization)                                     |
+|            |     [表格问题分类](https://huggingface.co/tasks/table-question-answering)     |   ✅   | [table_question_answering（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.table_question_answering)             |
+|            |         [文本分类](https://huggingface.co/tasks/text-classification)          |   ✅   | [text_classification（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.text_classification)                       |
+|            |      [Generation Text一代](https://huggingface.co/tasks/text-generation)      |   ✅   | [text_generation（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.text_generation)                               |
+|            |         [记号分类](https://huggingface.co/tasks/token-classification)         |   ✅   | [token_classification（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.token_classification)                     |
+|            |               [翻译](https://huggingface.co/tasks/translation)                |   ✅   | [translation（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.translation)                                       |
+|            |       [零炮分类](https://huggingface.co/tasks/zero-shot-classification)       |   ✅   | [零炮分类](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.zero_shot_classification)                                 |
+|    表格    |        [表格分类](https://huggingface.co/tasks/tabular-classification)        |   ✅   | [表分类](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.tabular_classification)                                     |
+|            |          [表格回归](https://huggingface.co/tasks/tabular-regression)          |   ✅   | [table_regression（）](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/inference_client#huggingface_hub.InferenceClient.tabular_regression)                           |
+
+任务页面： https://huggingface.co/tasks