Replace with Docker frontend

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.9.16
+ENV DEBIAN_FRONTEND=noninteractive \
+	TZ=Europe/Paris
+
+# BEGIN root part
+
+# Setup tailscale
+WORKDIR /bin
+ENV TSFILE=tailscale_1.38.2_amd64.tgz
+RUN wget https://pkgs.tailscale.com/stable/${TSFILE} && \
+  tar xzf ${TSFILE} --strip-components=1
+RUN mkdir -p /var/run && ln -s /tmp/tailscale /var/run/tailscale && \
+    mkdir -p /var/cache && ln -s /tmp/tailscale /var/cache/tailscale && \
+    mkdir -p /var/lib && ln -s /tmp/tailscale /var/lib/tailscale && \
+    mkdir -p /var/task && ln -s /tmp/tailscale /var/task/tailscale
+
+# Install socat
+RUN apt-get update && apt-get -y install socat
+
+# User
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+WORKDIR /home/user/app
+
+COPY --link --chown=1000 ./ $HOME/app
+
+ENTRYPOINT $HOME/app/startup.sh
+

app.py

@@ -1,469 +0,0 @@
-import gradio as gr
-import json
-import shutil
-import subprocess
-import urllib.parse
-from pathlib import Path
-
-from huggingface_hub import hf_hub_download, HfApi, scan_cache_dir
-from coremltools import ComputeUnit
-from coremltools.models.utils import _is_macos, _macos_version
-
-from transformers.onnx.utils import get_preprocessor
-
-from exporters.coreml import export
-from exporters.coreml.features import FeaturesManager
-from exporters.coreml.validate import validate_model_outputs
-
-compute_units_mapping = {
-    "All": ComputeUnit.ALL,
-    "CPU": ComputeUnit.CPU_ONLY,
-    "CPU + GPU": ComputeUnit.CPU_AND_GPU,
-    "CPU + NE": ComputeUnit.CPU_AND_NE,
-}
-compute_units_labels = list(compute_units_mapping.keys())
-
-framework_mapping = {
-    "PyTorch": "pt",
-    "TensorFlow": "tf",
-}
-framework_labels = list(framework_mapping.keys())
-
-precision_mapping = {
-    "Float32": "float32",
-    "Float16 quantization": "float16",
-}
-precision_labels = list(precision_mapping.keys())
-
-tolerance_mapping = {
-    "Model default": None,
-    "1e-2": 1e-2,
-    "1e-3": 1e-3,
-    "1e-4": 1e-4,
-}
-tolerance_labels = list(tolerance_mapping.keys())
-
-push_mapping = {
-    "Submit a PR to the original repo": "pr",
-    "Create a new repo": "new",
-}
-push_labels = list(push_mapping.keys())
-
-tasks_mapping = {
-    "default": "Feature Extraction",
-    "causal-lm": "Text Generation",
-    "ctc": "CTC (Connectionist Temporal Classification)",
-    "image-classification": "Image Classification",
-    "image-segmentation": "Image Segmentation",
-    "masked-im": "Image Fill-Mask",
-    "masked-lm": "Fill-Mask",
-    "multiple-choice": "Multiple Choice",
-    "next-sentence-prediction": "Next Sentence Prediction",
-    "object-detection": "Object Detection",
-    "question-answering": "Question Answering",
-    "semantic-segmentation": "Semantic Segmentation",
-    "seq2seq-lm": "Text to Text Generation",
-    "sequence-classification": "Text Classification",
-    "speech-seq2seq": "Audio to Audio",
-    "token-classification": "Token Classification",
-}
-reverse_tasks_mapping = {v: k for k, v in tasks_mapping.items()}
-tasks_labels = list(tasks_mapping.keys())
-
-# Map pipeline_tag to internal exporters features/tasks
-tags_to_tasks_mapping = {
-    "feature-extraction": "default",
-    "text-generation": "causal-lm",
-    "image-classification": "image-classification",
-    "image-segmentation": "image-segmentation",
-    "fill-mask": "masked-lm",
-    "object-detection": "object-detection",
-    "question-answering": "question-answering",
-    "text2text-generation": "seq2seq-lm",
-    "text-classification": "sequence-classification",
-    "token-classification": "token-classification",
-}
-
-def error_str(error, title="Error", model=None, task=None, framework=None, compute_units=None, precision=None, tolerance=None, destination=None, open_discussion=True):
-    if not error: return ""
-
-    discussion_text = ""
-    if open_discussion:
-        issue_title = urllib.parse.quote(f"Error converting {model}")
-        issue_description = urllib.parse.quote(f"""Conversion Settings:
-
-            Model: {model}
-            Task: {task}
-            Framework: {framework}
-            Compute Units: {compute_units}
-            Precision: {precision}
-            Tolerance: {tolerance}
-            Push to: {destination}
-
-            Error: {error}
-            """)
-        issue_url = f"https://huggingface.co/spaces/pcuenq/transformers-to-coreml/discussions/new?title={issue_title}&description={issue_description}"
-        discussion_text = f"You can open a discussion on the [Hugging Face Hub]({issue_url}) to report this issue."
-    return f"""
-        #### {title}
-        {error}
-
-        {discussion_text}
-        """
-
-def url_to_model_id(model_id_str):
-    if not model_id_str.startswith("https://huggingface.co/"): return model_id_str
-    return model_id_str.split("/")[-2] + "/" + model_id_str.split("/")[-1]
-
-def get_pr_url(api, repo_id, title):
-    try:
-        discussions = api.get_repo_discussions(repo_id=repo_id)
-    except Exception:
-        return None
-    for discussion in discussions:
-        if (
-            discussion.status == "open"
-            and discussion.is_pull_request
-            and discussion.title == title
-        ):
-            return f"https://huggingface.co/{repo_id}/discussions/{discussion.num}"
-
-def retrieve_model_info(model_id):
-    api = HfApi()
-    model_info = api.model_info(model_id)
-    tags = model_info.tags
-    frameworks = [tag for tag in tags if tag in ["pytorch", "tf"]]
-    return {
-        "pipeline_tag": model_info.pipeline_tag,
-        "frameworks": sorted(["PyTorch" if f == "pytorch" else "TensorFlow" for f in frameworks]),
-    }
-
-def supported_frameworks(model_info):
-    """
-    Return a list of supported frameworks (`PyTorch` or `TensorFlow`) for a given model_id.
-    Only PyTorch and Tensorflow are supported.
-    """
-    api = HfApi()
-    model_info = api.model_info(model_id)
-    tags = model_info.tags
-    frameworks = [tag for tag in tags if tag in ["pytorch", "tf"]]
-    return sorted(["PyTorch" if f == "pytorch" else "TensorFlow" for f in frameworks])
-
-def on_model_change(model):
-    model = url_to_model_id(model)    
-    tasks = None
-    error = None
-    frameworks = []
-    selected_framework = None
-    selected_task = None
-
-    try:
-        config_file = hf_hub_download(model, filename="config.json")
-        if config_file is None:
-            raise Exception(f"Model {model} not found")
-
-        with open(config_file, "r") as f:
-            config_json = f.read()
-
-        config = json.loads(config_json)
-        model_type = config["model_type"]
-
-        # Ignore `-with-past` for now
-        features = FeaturesManager.get_supported_features_for_model_type(model_type)
-        tasks = list(features.keys())
-        tasks = [task for task in tasks if "-with-past" not in task]
-
-        model_info = retrieve_model_info(model)
-        frameworks = model_info["frameworks"]
-        selected_framework = frameworks[0] if len(frameworks) > 0 else None
-
-        pipeline_tag = model_info["pipeline_tag"]
-        # print(pipeline_tag)
-        # Select the task corresponding to the pipeline tag
-        if tasks:
-            if pipeline_tag in tags_to_tasks_mapping:
-                selected_task = tags_to_tasks_mapping[pipeline_tag]
-            else:
-                selected_task = tasks[0]
-
-            # Convert to UI labels
-            tasks = [tasks_mapping[task] for task in tasks]
-            selected_task = tasks_mapping[selected_task]
-
-    except Exception as e:
-        error = e
-        model_type = None
-
-    return (
-        gr.update(visible=bool(model_type)),                                                    # Settings column
-        gr.update(choices=tasks, value=selected_task),                                          # Tasks
-        gr.update(visible=len(frameworks)>1, choices=frameworks, value=selected_framework),     # Frameworks
-        gr.update(value=error_str(error, model=model)),                                         # Error
-    )
-
-
-def convert_model(preprocessor, model, model_coreml_config,
-                  compute_units, precision, tolerance, output,
-                  use_past=False, seq2seq=None,
-                  progress=None, progress_start=0.1, progress_end=0.8):
-    coreml_config = model_coreml_config(model.config, use_past=use_past, seq2seq=seq2seq)
-
-    model_label = "model" if seq2seq is None else seq2seq
-    progress(progress_start, desc=f"Converting {model_label}")
-    mlmodel = export(
-        preprocessor,
-        model,
-        coreml_config,
-        quantize=precision,
-        compute_units=compute_units,
-    )
-
-    filename = output
-    if seq2seq == "encoder":
-        filename = filename.parent / ("encoder_" + filename.name)
-    elif seq2seq == "decoder":
-        filename = filename.parent / ("decoder_" + filename.name)
-    filename = filename.as_posix()
-
-    mlmodel.save(filename)
-
-    if _is_macos() and _macos_version() >= (12, 0):
-        progress(progress_end * 0.8, desc=f"Validating {model_label}")
-        if tolerance is None:
-            tolerance = coreml_config.atol_for_validation
-        validate_model_outputs(coreml_config, preprocessor, model, mlmodel, tolerance)
-    progress(progress_end, desc=f"Done converting {model_label}")
-
-
-def push_to_hub(destination, directory, task, precision, token=None):
-    api = HfApi(token=token)
-    api.create_repo(destination, token=token, exist_ok=True)
-    commit_message="Add Core ML conversion"
-    api.upload_folder(
-        folder_path=directory,
-        repo_id=destination,
-        token=token,
-        create_pr=True,
-        commit_message=commit_message,
-        commit_description=f"Core ML conversion, task={task}, precision={precision}",
-    )
-
-    subprocess.run(["rm", "-rf", directory])
-    return get_pr_url(HfApi(token=token), destination, commit_message)
-
-
-def cleanup(model_id, exported):
-    if exported:
-        shutil.rmtree(exported)
-
-    # We remove the model from the huggingface cache, so it will have to be downloaded again
-    # if the user wants to convert it for a different task or precision.
-    # Alternatively, we could remove models older than 1 day or so.
-    cache_info = scan_cache_dir()
-    try:
-        repo = next(repo for repo in cache_info.repos if repo.repo_id==model_id)
-    except StopIteration:
-        # The model was not in the cache!
-        return
-
-    if repo is not None:
-        for revision in repo.revisions:
-            delete_strategy = cache_info.delete_revisions(revision.commit_hash)
-            delete_strategy.execute()
-
-
-def convert(model_id, task,
-            compute_units, precision, tolerance, framework,
-            push_destination, destination_model, token,
-            progress=gr.Progress()):
-    model_id = url_to_model_id(model_id)
-    task = reverse_tasks_mapping[task]
-    compute_units = compute_units_mapping[compute_units]
-    precision = precision_mapping[precision]
-    tolerance = tolerance_mapping[tolerance]
-    framework = framework_mapping[framework]
-    push_destination = push_mapping[push_destination]
-    if push_destination == "pr":
-        destination_model = model_id
-
-    if token is None or token == "":
-        return error_str("Please provide a token to push to the Hub.", open_discussion=False)
-
-    # TODO: support legacy format
-    exported_base = Path("exported")/model_id
-    output = exported_base/"coreml"/task
-    output.mkdir(parents=True, exist_ok=True)
-    output = output/f"{precision}_model.mlpackage"
-
-    try:
-        progress(0, desc="Downloading model")
-
-        preprocessor = get_preprocessor(model_id)
-        model = FeaturesManager.get_model_from_feature(task, model_id, framework=framework)
-        _, model_coreml_config = FeaturesManager.check_supported_model_or_raise(model, feature=task)
-
-        if task in ["seq2seq-lm", "speech-seq2seq"]:
-            convert_model(
-                preprocessor,
-                model,
-                model_coreml_config,
-                compute_units,
-                precision,
-                tolerance,
-                output,
-                seq2seq="encoder",
-                progress=progress,
-                progress_start=0.1,
-                progress_end=0.4,
-            )
-            progress(0.4, desc="Converting decoder")
-            convert_model(
-                preprocessor,
-                model,
-                model_coreml_config,
-                compute_units,
-                precision,
-                tolerance,
-                output,
-                seq2seq="decoder",
-                progress=progress,
-                progress_start=0.4,
-                progress_end=0.7,
-            )
-        else:
-            convert_model(
-                preprocessor,
-                model,
-                model_coreml_config,
-                compute_units,
-                precision,
-                tolerance,
-                output,
-                progress=progress,
-                progress_end=0.7,
-            )
-
-        progress(0.7, "Uploading model to Hub")
-        pr_url = push_to_hub(destination_model, exported_base, task, precision, token=token)
-        progress(1, "Done")
-
-        cleanup(model_id, exported_base)
-
-        did_validate = _is_macos() and _macos_version() >= (12, 0)
-        result = f"""### Successfully converted!
-        We opened a PR to add the Core ML weights to the model repo. Please, view and merge the PR [here]({pr_url}).
-
-        {f"**Note**: model could not be automatically validated as this Space is not running on macOS." if not did_validate else ""}
-        """
-        return result
-    except Exception as e:
-        return error_str(e, model=model_id, task=task, framework=framework, compute_units=compute_units, precision=precision, tolerance=tolerance)
-
-DESCRIPTION = """
-## Convert a `transformers` model to Core ML
-
-With this Space you can try to convert a transformers model to Core ML. It uses the 🤗 Hugging Face [Exporters repo](https://github.com/huggingface/exporters) under the hood.
-
-Note that not all models are supported. If you get an error on a model you'd like to convert, please open an issue in the discussions tab of this Space. You'll get a link to do it when an error occurs.
-"""
-
-with gr.Blocks() as demo:
-    gr.Markdown(DESCRIPTION)
-    with gr.Row():
-        with gr.Column(scale=2):
-            gr.Markdown("## 1. Load model info")
-            input_model = gr.Textbox(
-                max_lines=1,
-                label="Model name or URL, such as apple/mobilevit-small",
-                placeholder="pcuenq/distilbert-base-uncased",
-                value="pcuenq/distilbert-base-uncased",
-            )
-            btn_get_tasks = gr.Button("Load")
-        with gr.Column(scale=3):
-            with gr.Column(visible=False) as group_settings:
-                gr.Markdown("## 2. Select Task")
-                radio_tasks = gr.Radio(label="Choose the task for the converted model.")
-                gr.Markdown("The `default` task is suitable for feature extraction.")
-                radio_framework = gr.Radio(
-                    visible=False,
-                    label="Framework",
-                    choices=framework_labels,
-                    value=framework_labels[0],
-                )
-                radio_compute = gr.Radio(
-                    label="Compute Units",
-                    choices=compute_units_labels,
-                    value=compute_units_labels[0],
-                )
-                radio_precision = gr.Radio(
-                    label="Precision",
-                    choices=precision_labels,
-                    value=precision_labels[0],
-                )
-                radio_tolerance = gr.Radio(
-                    label="Absolute Tolerance for Validation",
-                    choices=tolerance_labels,
-                    value=tolerance_labels[0],
-                )
-
-                with gr.Group():
-                    text_token = gr.Textbox(label="Hugging Face Token", placeholder="hf_xxxx", value="")
-                    radio_push = gr.Radio(
-                        label="Destination Model",
-                        choices=push_labels,
-                        value=push_labels[0],
-                    )
-                    # TODO: public/private
-                    text_destination = gr.Textbox(visible=False, label="Destination model name", value="")
-
-                btn_convert = gr.Button("Convert & Push")
-                gr.Markdown("Conversion will take a few minutes.")
-
-
-    error_output = gr.Markdown(label="Output")
-
-    # # Clear output
-    # btn_get_tasks.click(lambda _: gr.update(value=''), None, error_output)
-    # input_model.submit(lambda _: gr.update(value=''), None, error_output)
-    # btn_convert.click(lambda _: gr.update(value=''), None, error_output)
-
-    input_model.submit(
-        fn=on_model_change,
-        inputs=input_model,
-        outputs=[group_settings, radio_tasks, radio_framework, error_output],
-        queue=False,
-        scroll_to_output=True
-    )
-    btn_get_tasks.click(
-        fn=on_model_change,
-        inputs=input_model,
-        outputs=[group_settings, radio_tasks, radio_framework, error_output],
-        queue=False,
-        scroll_to_output=True
-    )
-        
-    btn_convert.click(
-        fn=convert,
-        inputs=[input_model, radio_tasks, radio_compute, radio_precision, radio_tolerance, radio_framework, radio_push, text_destination, text_token],
-        outputs=error_output,
-        scroll_to_output=True,
-        # api_name="convert",
-    )
-
-    radio_push.change(
-        lambda x: gr.update(visible=x == "Create a new repo"),
-        inputs=radio_push,
-        outputs=text_destination,
-        queue=False,
-        scroll_to_output=False
-    )
-
-    gr.HTML("""
-    <div style="border-top: 0.5px solid #303030;">
-      <br>
-      <p style="color:gray;font-size:smaller;font-style:italic">Adapted from https://huggingface.co/spaces/diffusers/sd-to-diffusers/tree/main</p><br>
-    </div>
-    """)
-    
-demo.queue(concurrency_count=1, max_size=10)
-demo.launch(debug=True, share=False)

requirements.txt

@@ -1,5 +0,0 @@
-huggingface_hub
-transformers
-coremltools
-git+https://github.com/huggingface/exporters.git
-torch~=1.13

startup.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+# start tailscale
+echo "Start tailscale"
+mkdir -p /tmp/tailscale
+/bin/tailscaled --tun=userspace-networking --outbound-http-proxy-listen=localhost:1055 --state=/var/lib/tailscale/tailscaled.state --socket=/var/run/tailscale/tailscaled.sock &
+HOSTNAME=${SPACE_HOST#"https://"}
+/bin/tailscale up --authkey ${TS_AUTHKEY} --hostname=${HOSTNAME} --accept-routes --accept-dns
+echo "Tailscale started"
+echo
+
+echo "redirect 7860 -> backend through tailscale"
+socat TCP4-LISTEN:7860,reuseaddr,fork PROXY:localhost:10.254.0.11:7860,proxyport=1055