Create helper.py

helper.py

@@ -0,0 +1,232 @@
+import io
+import matplotlib.pyplot as plt
+import requests
+import inflect
+from PIL import Image
+import torch
+import numpy as np
+
+def load_image_from_url(url):
+    return Image.open(requests.get(url, stream=True).raw)
+
+def render_results_in_image(in_pil_img, in_results):
+    plt.figure(figsize=(16, 10))
+    plt.imshow(in_pil_img)
+
+    ax = plt.gca()
+
+    for prediction in in_results:
+
+        x, y = prediction['box']['xmin'], prediction['box']['ymin']
+        w = prediction['box']['xmax'] - prediction['box']['xmin']
+        h = prediction['box']['ymax'] - prediction['box']['ymin']
+
+        ax.add_patch(plt.Rectangle((x, y),
+                                   w,
+                                   h,
+                                   fill=False,
+                                   color="green",
+                                   linewidth=2))
+        ax.text(
+           x,
+           y,
+           f"{prediction['label']}: {round(prediction['score']*100, 1)}%",
+           color='red'
+        )
+
+    plt.axis("off")
+
+    # Save the modified image to a BytesIO object
+    img_buf = io.BytesIO()
+    plt.savefig(img_buf, format='png',
+                bbox_inches='tight',
+                pad_inches=0)
+    img_buf.seek(0)
+    modified_image = Image.open(img_buf)
+
+    # Close the plot to prevent it from being displayed
+    plt.close()
+
+    return modified_image
+
+def summarize_predictions_natural_language(predictions):
+    summary = {}
+    p = inflect.engine()
+
+    for prediction in predictions:
+        label = prediction['label']
+        if label in summary:
+            summary[label] += 1
+        else:
+            summary[label] = 1
+
+    result_string = "In this image, there are "
+    for i, (label, count) in enumerate(summary.items()):
+        count_string = p.number_to_words(count)
+        result_string += f"{count_string} {label}"
+        if count > 1:
+          result_string += "s"
+
+        result_string += " "
+
+        if i == len(summary) - 2:
+          result_string += "and "
+
+    # Remove the trailing comma and space
+    result_string = result_string.rstrip(', ') + "."
+
+    return result_string
+
+
+##### To ignore warnings #####
+import warnings
+import logging
+from transformers import logging as hf_logging
+
+def ignore_warnings():
+    # Ignore specific Python warnings
+    warnings.filterwarnings("ignore", message="Some weights of the model checkpoint")
+    warnings.filterwarnings("ignore", message="Could not find image processor class")
+    warnings.filterwarnings("ignore", message="The `max_size` parameter is deprecated")
+
+    # Adjust logging for libraries using the logging module
+    logging.basicConfig(level=logging.ERROR)
+    hf_logging.set_verbosity_error()
+
+########
+
+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 show_box(box, ax):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(plt.Rectangle((x0, y0),
+                               w,
+                               h, edgecolor='green',
+                               facecolor=(0,0,0,0),
+                               lw=2))
+
+def show_boxes_on_image(raw_image, boxes):
+    plt.figure(figsize=(10,10))
+    plt.imshow(raw_image)
+    for box in boxes:
+      show_box(box, plt.gca())
+    plt.axis('on')
+    plt.show()
+
+def show_points_on_image(raw_image, input_points, input_labels=None):
+    plt.figure(figsize=(10,10))
+    plt.imshow(raw_image)
+    input_points = np.array(input_points)
+    if input_labels is None:
+      labels = np.ones_like(input_points[:, 0])
+    else:
+      labels = np.array(input_labels)
+    show_points(input_points, labels, plt.gca())
+    plt.axis('on')
+    plt.show()
+
+def show_points_and_boxes_on_image(raw_image,
+                                   boxes,
+                                   input_points,
+                                   input_labels=None):
+    plt.figure(figsize=(10,10))
+    plt.imshow(raw_image)
+    input_points = np.array(input_points)
+    if input_labels is None:
+      labels = np.ones_like(input_points[:, 0])
+    else:
+      labels = np.array(input_labels)
+    show_points(input_points, labels, plt.gca())
+    for box in boxes:
+      show_box(box, plt.gca())
+    plt.axis('on')
+    plt.show()
+
+
+def show_points_and_boxes_on_image(raw_image,
+                                   boxes,
+                                   input_points,
+                                   input_labels=None):
+    plt.figure(figsize=(10,10))
+    plt.imshow(raw_image)
+    input_points = np.array(input_points)
+    if input_labels is None:
+      labels = np.ones_like(input_points[:, 0])
+    else:
+      labels = np.array(input_labels)
+    show_points(input_points, labels, plt.gca())
+    for box in boxes:
+      show_box(box, plt.gca())
+    plt.axis('on')
+    plt.show()
+
+
+def show_points(coords, labels, ax, marker_size=375):
+    pos_points = coords[labels==1]
+    neg_points = coords[labels==0]
+    ax.scatter(pos_points[:, 0],
+               pos_points[:, 1],
+               color='green',
+               marker='*',
+               s=marker_size,
+               edgecolor='white',
+               linewidth=1.25)
+    ax.scatter(neg_points[:, 0],
+               neg_points[:, 1],
+               color='red',
+               marker='*',
+               s=marker_size,
+               edgecolor='white',
+               linewidth=1.25)
+
+
+def fig2img(fig):
+    """Convert a Matplotlib figure to a PIL Image and return it"""
+    import io
+    buf = io.BytesIO()
+    fig.savefig(buf)
+    buf.seek(0)
+    img = Image.open(buf)
+    return img
+
+
+def show_mask_on_image(raw_image, mask, return_image=False):
+    if not isinstance(mask, torch.Tensor):
+      mask = torch.Tensor(mask)
+
+    if len(mask.shape) == 4:
+      mask = mask.squeeze()
+
+    fig, axes = plt.subplots(1, 1, figsize=(15, 15))
+
+    mask = mask.cpu().detach()
+    axes.imshow(np.array(raw_image))
+    show_mask(mask, axes)
+    axes.axis("off")
+    plt.show()
+
+    if return_image:
+      fig = plt.gcf()
+      return fig2img(fig)
+
+
+
+
+def show_pipe_masks_on_image(raw_image, outputs):
+  plt.imshow(np.array(raw_image))
+  ax = plt.gca()
+  for mask in outputs["masks"]:
+      show_mask(mask, ax=ax, random_color=True)
+  plt.axis("off")
+  plt.show()