Upload folder using huggingface_hub

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,6 @@
 ---
-title: Segmentanything
-emoji: 🦀
-colorFrom: blue
-colorTo: yellow
+title: segmentanything
+app_file: text_to_sam_clip.py
 sdk: gradio
 sdk_version: 5.9.1
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

amg_paddle.py

@@ -0,0 +1,308 @@
+# Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This implementation refers to: https://github.com/facebookresearch/segment-anything
+
+import os
+import sys
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+
+import time
+import cv2  # type: ignore
+import argparse
+import numpy as np  # type: ignore
+import paddle
+
+from segment_anything import SamAutomaticMaskGenerator, sam_model_registry
+from paddleseg.utils.visualize import get_pseudo_color_map, get_color_map_list
+
+ID_PHOTO_IMAGE_DEMO = "examples/cityscapes_demo.png"
+CACHE_DIR = ".temp"
+
+model_link = {
+    'vit_h':
+    "https://bj.bcebos.com/paddleseg/dygraph/paddlesegAnything/vit_h/model.pdparams",
+    'vit_l':
+    "https://bj.bcebos.com/paddleseg/dygraph/paddlesegAnything/vit_l/model.pdparams",
+    'vit_b':
+    "https://bj.bcebos.com/paddleseg/dygraph/paddlesegAnything/vit_b/model.pdparams",
+    'vit_t':
+    "https://paddleseg.bj.bcebos.com/dygraph/paddlesegAnything/vit_t/model.pdparam"
+}
+
+parser = argparse.ArgumentParser(description=(
+    "Runs automatic mask generation on an input image or directory of images, "
+    "and outputs masks as either PNGs or COCO-style RLEs. Requires open-cv, "
+    "as well as pycocotools if saving in RLE format."))
+
+parser.add_argument(
+    "--model-type",
+    type=str,
+    default="vit_l",
+    required=True,
+    help="The type of model to load, in ['vit_h', 'vit_l', 'vit_b', 'vit_t']", )
+
+parser.add_argument(
+    "--convert-to-rle",
+    action="store_true",
+    help=(
+        "Save masks as COCO RLEs in a single json instead of as a folder of PNGs. "
+        "Requires pycocotools."), )
+
+amg_settings = parser.add_argument_group("AMG Settings")
+
+amg_settings.add_argument(
+    "--points-per-side",
+    type=int,
+    default=None,
+    help="Generate masks by sampling a grid over the image with this many points to a side.",
+)
+
+amg_settings.add_argument(
+    "--points-per-batch",
+    type=int,
+    default=None,
+    help="How many input points to process simultaneously in one batch.", )
+
+amg_settings.add_argument(
+    "--pred-iou-thresh",
+    type=float,
+    default=None,
+    help="Exclude masks with a predicted score from the model that is lower than this threshold.",
+)
+
+amg_settings.add_argument(
+    "--stability-score-thresh",
+    type=float,
+    default=None,
+    help="Exclude masks with a stability score lower than this threshold.", )
+
+amg_settings.add_argument(
+    "--stability-score-offset",
+    type=float,
+    default=None,
+    help="Larger values perturb the mask more when measuring stability score.",
+)
+
+amg_settings.add_argument(
+    "--box-nms-thresh",
+    type=float,
+    default=None,
+    help="The overlap threshold for excluding a duplicate mask.", )
+
+amg_settings.add_argument(
+    "--crop-n-layers",
+    type=int,
+    default=None,
+    help=(
+        "If >0, mask generation is run on smaller crops of the image to generate more masks. "
+        "The value sets how many different scales to crop at."), )
+
+amg_settings.add_argument(
+    "--crop-nms-thresh",
+    type=float,
+    default=None,
+    help="The overlap threshold for excluding duplicate masks across different crops.",
+)
+
+amg_settings.add_argument(
+    "--crop-overlap-ratio",
+    type=int,
+    default=None,
+    help="Larger numbers mean image crops will overlap more.", )
+
+amg_settings.add_argument(
+    "--crop-n-points-downscale-factor",
+    type=int,
+    default=None,
+    help="The number of points-per-side in each layer of crop is reduced by this factor.",
+)
+
+amg_settings.add_argument(
+    "--min-mask-region-area",
+    type=int,
+    default=None,
+    help=(
+        "Disconnected mask regions or holes with area smaller than this value "
+        "in pixels are removed by postprocessing."), )
+
+
+def get_amg_kwargs(args):
+    amg_kwargs = {
+        "points_per_side": args.points_per_side,
+        "points_per_batch": args.points_per_batch,
+        "pred_iou_thresh": args.pred_iou_thresh,
+        "stability_score_thresh": args.stability_score_thresh,
+        "stability_score_offset": args.stability_score_offset,
+        "box_nms_thresh": args.box_nms_thresh,
+        "crop_n_layers": args.crop_n_layers,
+        "crop_nms_thresh": args.crop_nms_thresh,
+        "crop_overlap_ratio": args.crop_overlap_ratio,
+        "crop_n_points_downscale_factor": args.crop_n_points_downscale_factor,
+        "min_mask_region_area": args.min_mask_region_area,
+    }
+    amg_kwargs = {k: v for k, v in amg_kwargs.items() if v is not None}
+    return amg_kwargs
+
+
+def delete_result():
+    """clear old result in `.temp`"""
+    results = sorted(os.listdir(CACHE_DIR))
+    for res in results:
+        if int(time.time()) - int(os.path.splitext(res)[0]) > 10000:
+            os.remove(os.path.join(CACHE_DIR, res))
+
+
+def download(img):
+    if not os.path.exists(CACHE_DIR):
+        os.makedirs(CACHE_DIR)
+    while True:
+        name = str(int(time.time()))
+        tmp_name = os.path.join(CACHE_DIR, name + '.jpg')
+        if not os.path.exists(tmp_name):
+            break
+        else:
+            time.sleep(1)
+
+    img.save(tmp_name, 'png')
+    return tmp_name
+
+
+def masks2pseudomap(masks):
+    result = np.ones(masks[0]["segmentation"].shape, dtype=np.uint8) * 255
+    for i, mask_data in enumerate(masks):
+        result[mask_data["segmentation"] == 1] = i + 1
+    pred_result = result
+    result = get_pseudo_color_map(result)
+
+    return pred_result, result
+
+
+def visualize(image, result, color_map, weight=0.6):
+    """
+    Convert predict result to color image, and save added image.
+
+    Args:
+        image (str): The path of origin image.
+        result (np.ndarray): The predict result of image.
+        color_map (list): The color used to save the prediction results.
+        save_dir (str): The directory for saving visual image. Default: None.
+        weight (float): The image weight of visual image, and the result weight is (1 - weight). Default: 0.6
+
+    Returns:
+        vis_result (np.ndarray): If `save_dir` is None, return the visualized result.
+    """
+
+    color_map = [color_map[i:i + 3] for i in range(0, len(color_map), 3)]
+    color_map = np.array(color_map).astype("uint8")
+    # Use OpenCV LUT for color mapping
+    c1 = cv2.LUT(result, color_map[:, 0])
+    c2 = cv2.LUT(result, color_map[:, 1])
+    c3 = cv2.LUT(result, color_map[:, 2])
+    pseudo_img = np.dstack((c3, c2, c1))
+
+    # im = cv2.imread(image)
+    vis_result = cv2.addWeighted(image, weight, pseudo_img, 1 - weight, 0)
+    return vis_result
+
+
+def gradio_display(generator):
+    import gradio as gr
+
+    def clear_image_all():
+        delete_result()
+        return None, None, None, None
+
+    def get_id_photo_output(img):
+        """
+        Get the special size and background photo.
+
+        Args:
+            img(numpy:ndarray): The image array.
+            size(str): The size user specified.
+            bg(str): The background color user specified.
+            download_size(str): The size for image saving.
+
+        """
+        predictor = generator
+        masks = predictor.generate(img)
+        pred_result, pseudo_map = masks2pseudomap(masks)  # PIL Image
+        added_pseudo_map = visualize(
+            img, pred_result, color_map=get_color_map_list(256))
+        res_download = download(pseudo_map)
+
+        return pseudo_map, added_pseudo_map, res_download
+
+    with gr.Blocks() as demo:
+        gr.Markdown("""# Segment Anything (PaddleSeg) """)
+        with gr.Tab("InputImage"):
+            image_in = gr.Image(value=ID_PHOTO_IMAGE_DEMO, label="Input image")
+
+            with gr.Row():
+                image_clear_btn = gr.Button("Clear")
+                image_submit_btn = gr.Button("Submit")
+
+            with gr.Row():
+                img_out1 = gr.Image(
+                    label="Output image", interactive=False).style(height=300)
+                img_out2 = gr.Image(
+                    label="Output image with mask",
+                    interactive=False).style(height=300)
+            downloaded_img = gr.File(label='Image download').style(height=50)
+
+        image_clear_btn.click(
+            fn=clear_image_all,
+            inputs=None,
+            outputs=[image_in, img_out1, img_out2, downloaded_img])
+
+        image_submit_btn.click(
+            fn=get_id_photo_output,
+            inputs=[image_in, ],
+            outputs=[img_out1, img_out2, downloaded_img])
+
+        gr.Markdown(
+            """<font color=Gray>Tips: You can try segment the default image OR upload any images you want to segment by click on the clear button first.</font>"""
+        )
+
+        gr.Markdown(
+            """<font color=Gray>This is Segment Anything build with PaddlePaddle. 
+            We refer to the [SAM](https://github.com/facebookresearch/segment-anything) for code strucure and model architecture.
+            If you have any question or feature request, welcome to raise issues on [GitHub](https://github.com/PaddlePaddle/PaddleSeg/issues). </font>"""
+        )
+
+        gr.Button.style(1)
+
+    demo.launch(server_name="0.0.0.0", server_port=8017, share=True)
+
+
+def main(args: argparse.Namespace) -> None:
+    print("Loading model...")
+
+    sam = sam_model_registry[args.model_type](
+        checkpoint=model_link[args.model_type])
+    if paddle.is_compiled_with_cuda():
+        paddle.set_device("gpu")
+    else:
+        paddle.set_device("cpu")
+    output_mode = "coco_rle" if args.convert_to_rle else "binary_mask"
+    amg_kwargs = get_amg_kwargs(args)
+    generator = SamAutomaticMaskGenerator(
+        sam, output_mode=output_mode, **amg_kwargs)
+
+    gradio_display(generator)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+    main(args)

promt_predict.py

@@ -0,0 +1,128 @@
+# Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This implementation refers to: https://github.com/facebookresearch/segment-anything
+
+import os
+import sys
+import argparse
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+
+import paddle
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+from segment_anything.predictor import SamPredictor
+from segment_anything.build_sam import sam_model_registry
+
+model_link = {
+    'vit_h':
+    "https://bj.bcebos.com/paddleseg/dygraph/paddlesegAnything/vit_h/model.pdparams",
+    'vit_l':
+    "https://bj.bcebos.com/paddleseg/dygraph/paddlesegAnything/vit_l/model.pdparams",
+    'vit_b':
+    "https://bj.bcebos.com/paddleseg/dygraph/paddlesegAnything/vit_b/model.pdparams",
+    'vit_t':
+    "https://paddleseg.bj.bcebos.com/dygraph/paddlesegAnything/vit_t/model.pdparam"
+}
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        description='Segment image with point promp or box')
+    # Parameters
+    parser.add_argument(
+        '--input_path', type=str, required=True, help='The directory of image.')
+    parser.add_argument(
+        "--model-type",
+        type=str,
+        default="vit_l",
+        required=True,
+        help="The type of model to load, in ['vit_h', 'vit_l', 'vit_b', 'vit_t']",
+    )
+    parser.add_argument(
+        '--point_prompt',
+        type=int,
+        nargs='+',
+        default=None,
+        help='point prompt.')
+    parser.add_argument(
+        '--box_prompt',
+        type=int,
+        nargs='+',
+        default=None,
+        help='box prompt format as xyxy.')
+    parser.add_argument(
+        '--output_path',
+        type=str,
+        default='./output/',
+        help='The directory for saving the results')
+    return parser.parse_args()
+
+
+def show_mask(mask, ax, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        color = np.array([30 / 255, 144 / 255, 255 / 255, 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def main(args):
+    if paddle.is_compiled_with_cuda():
+        paddle.set_device("gpu")
+    else:
+        paddle.set_device("cpu")
+    input_path = args.input_path
+    output_path = args.output_path
+    point, box = args.point_prompt, args.box_prompt
+    if point is not None:
+        point = np.array([point])
+        input_label = np.array([1])
+    else:
+        input_label = None
+    if box is not None:
+        box = np.array([[box[0], box[1]], [box[2], box[3]]])
+
+    image = cv2.imread(input_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    model = sam_model_registry[args.model_type](
+        checkpoint=model_link[args.model_type])
+    predictor = SamPredictor(model)
+    predictor.set_image(image)
+
+    masks, _, _ = predictor.predict(
+        point_coords=point,
+        point_labels=input_label,
+        box=box,
+        multimask_output=True, )
+
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image)
+    show_mask(masks[0], plt.gca())
+    plt.axis('off')
+    basename = os.path.basename(input_path)
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+    path_output = os.path.join(output_path, basename)
+    plt.savefig(path_output)
+    print('The output has been saved to {}'.format(path_output))
+
+
+if __name__ == "__main__":
+    args = get_args()
+    main(args)

text_to_sam_clip.py

@@ -0,0 +1,241 @@
+# Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import cv2
+import time
+import sys
+import argparse
+sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
+
+import paddle
+import paddle.nn.functional as F
+import numpy as np
+from PIL import Image, ImageDraw
+import matplotlib.pyplot as plt
+
+from segment_anything import sam_model_registry, SamAutomaticMaskGenerator
+from segment_anything.modeling.clip_paddle import build_clip_model, _transform
+from segment_anything.utils.sample_tokenizer import tokenize
+from paddleseg.utils.visualize import get_pseudo_color_map, get_color_map_list
+
+ID_PHOTO_IMAGE_DEMO = "./examples/cityscapes_demo.png"
+CACHE_DIR = ".temp"
+model_link = {
+    'vit_h':
+    "https://bj.bcebos.com/paddleseg/dygraph/paddlesegAnything/vit_h/model.pdparams",
+    'vit_l':
+    "https://bj.bcebos.com/paddleseg/dygraph/paddlesegAnything/vit_l/model.pdparams",
+    'vit_b':
+    "https://bj.bcebos.com/paddleseg/dygraph/paddlesegAnything/vit_b/model.pdparams",
+    'vit_t':
+    "https://paddleseg.bj.bcebos.com/dygraph/paddlesegAnything/vit_t/model.pdparam",
+    'clip_b_32':
+    "https://bj.bcebos.com/paddleseg/dygraph/clip/vit_b_32_pretrain/clip_vit_b_32.pdparams"
+}
+
+parser = argparse.ArgumentParser(description=(
+    "Runs automatic mask generation on an input image or directory of images, "
+    "and outputs masks as either PNGs or COCO-style RLEs. Requires open-cv, "
+    "as well as pycocotools if saving in RLE format."))
+
+parser.add_argument(
+    "--model-type",
+    type=str,
+    default="vit_h",
+    required=True,
+    help="The type of model to load, in ['vit_h', 'vit_l', 'vit_b', 'vit_t']", )
+
+
+def download(img):
+    if not os.path.exists(CACHE_DIR):
+        os.makedirs(CACHE_DIR)
+    while True:
+        name = str(int(time.time()))
+        tmp_name = os.path.join(CACHE_DIR, name + '.jpg')
+        if not os.path.exists(tmp_name):
+            break
+        else:
+            time.sleep(1)
+    img.save(tmp_name, 'png')
+    return tmp_name
+
+
+def segment_image(image, segment_mask):
+    image_array = np.array(image)
+    gray_image = Image.new("RGB", image.size, (128, 128, 128))
+    segmented_image_array = np.zeros_like(image_array)
+    segmented_image_array[segment_mask] = image_array[segment_mask]
+    segmented_image = Image.fromarray(segmented_image_array)
+    transparency = np.zeros_like(segment_mask, dtype=np.uint8)
+    transparency[segment_mask] = 255
+    transparency_image = Image.fromarray(transparency, mode='L')
+    gray_image.paste(segmented_image, mask=transparency_image)
+    return gray_image
+
+
+def image_text_match(cropped_objects, text_query):
+    transformed_images = [transform(image) for image in cropped_objects]
+    tokenized_text = tokenize([text_query])
+    batch_images = paddle.stack(transformed_images)
+    image_features = model.encode_image(batch_images)
+    print("encode_image done!")
+    text_features = model.encode_text(tokenized_text)
+    print("encode_text done!")
+    image_features /= image_features.norm(axis=-1, keepdim=True)
+    text_features /= text_features.norm(axis=-1, keepdim=True)
+    if len(text_features.shape) == 3:
+        text_features = text_features.squeeze(0)
+    probs = 100. * image_features @text_features.T
+    return F.softmax(probs[:, 0], axis=0)
+
+
+def masks2pseudomap(masks):
+    result = np.ones(masks[0]["segmentation"].shape, dtype=np.uint8) * 255
+    for i, mask_data in enumerate(masks):
+        result[mask_data["segmentation"] == 1] = i + 1
+    pred_result = result
+    result = get_pseudo_color_map(result)
+    return pred_result, result
+
+
+def visualize(image, result, color_map, weight=0.6):
+    """
+    Convert predict result to color image, and save added image.
+
+    Args:
+        image (str): The path of origin image.
+        result (np.ndarray): The predict result of image.
+        color_map (list): The color used to save the prediction results.
+        save_dir (str): The directory for saving visual image. Default: None.
+        weight (float): The image weight of visual image, and the result weight is (1 - weight). Default: 0.6
+
+    Returns:
+        vis_result (np.ndarray): If `save_dir` is None, return the visualized result.
+    """
+
+    color_map = [color_map[i:i + 3] for i in range(0, len(color_map), 3)]
+    color_map = np.array(color_map).astype("uint8")
+    # Use OpenCV LUT for color mapping
+    c1 = cv2.LUT(result, color_map[:, 0])
+    c2 = cv2.LUT(result, color_map[:, 1])
+    c3 = cv2.LUT(result, color_map[:, 2])
+    pseudo_img = np.dstack((c3, c2, c1))
+
+    vis_result = cv2.addWeighted(image, weight, pseudo_img, 1 - weight, 0)
+    return vis_result
+
+
+def get_id_photo_output(image, text):
+    """
+    Get the special size and background photo.
+
+    Args:
+        img(numpy:ndarray): The image array.
+        size(str): The size user specified.
+        bg(str): The background color user specified.
+        download_size(str): The size for image saving.
+
+    """
+    image_ori = image.copy()
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    masks = mask_generator.generate(image)
+    pred_result, pseudo_map = masks2pseudomap(masks)  # PIL Image
+    added_pseudo_map = visualize(
+        image, pred_result, color_map=get_color_map_list(256))
+    cropped_objects = []
+    image_pil = Image.fromarray(image)
+    for mask in masks:
+        bbox = [
+            mask["bbox"][0], mask["bbox"][1], mask["bbox"][0] + mask["bbox"][2],
+            mask["bbox"][1] + mask["bbox"][3]
+        ]
+        cropped_objects.append(
+            segment_image(image_pil, mask["segmentation"]).crop(bbox))
+
+    scores = image_text_match(cropped_objects, str(text))
+    text_matching_masks = []
+    for idx, score in enumerate(scores):
+        if score < 0.05:
+            continue
+        text_matching_mask = Image.fromarray(
+            masks[idx]["segmentation"].astype('uint8') * 255)
+        text_matching_masks.append(text_matching_mask)
+
+    image_pil_ori = Image.fromarray(image_ori)
+    alpha_image = Image.new('RGBA', image_pil_ori.size, (0, 0, 0, 0))
+    alpha_color = (255, 0, 0, 180)
+
+    draw = ImageDraw.Draw(alpha_image)
+    for text_matching_mask in text_matching_masks:
+        draw.bitmap((0, 0), text_matching_mask, fill=alpha_color)
+
+    result_image = Image.alpha_composite(
+        image_pil_ori.convert('RGBA'), alpha_image)
+    res_download = download(result_image)
+    return result_image, added_pseudo_map, res_download
+
+
+def gradio_display():
+    import gradio as gr
+    examples_sam = [["./examples/cityscapes_demo.png", "a photo of car"],
+                    ["examples/dog.jpg", "dog"],
+                    ["examples/zixingche.jpeg", "kid"]]
+
+    demo_mask_sam = gr.Interface(
+        fn=get_id_photo_output,
+        inputs=[
+            gr.Image(label="Input image", height=400),
+            gr.Textbox(label="Input text prompt", value="a car"),
+        ],
+        outputs=[
+            gr.Image(label="Output based on text", height=300),
+            gr.Image(label="Output mask", height=300)
+        ],
+        examples=examples_sam,
+        description="<p> \
+                        <strong>SAM+CLIP:  Text prompt for segmentation. </strong> <br>\
+                        Choose an example below; Or, upload by yourself: <br>\
+                        1. Upload images to be tested to 'input image'. 2. Input a text prompt to 'input text prompt' and click 'submit'</strong>.  <br>\
+                        </p>",
+        cache_examples=False,
+        flagging_mode="never"
+    )
+
+    demo = gr.TabbedInterface(
+        [demo_mask_sam],
+        ['SAM+CLIP(Text to Segment)'],
+        title=" 🔥 Text to Segment Anything with PaddleSeg 🔥"
+    )
+    
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=8078,
+        share=True
+    )
+
+args = parser.parse_args()
+print("Loading model...")
+
+if paddle.is_compiled_with_cuda():
+    paddle.set_device("gpu")
+else:
+    paddle.set_device("cpu")
+
+sam = sam_model_registry[args.model_type](
+    checkpoint=model_link[args.model_type])
+mask_generator = SamAutomaticMaskGenerator(sam)
+
+model, transform = build_clip_model(model_link["clip_b_32"])
+gradio_display()