Upload 3 files

Dockerfile

@@ -0,0 +1,30 @@
+#Use the official Python 3.9 image
+FROM python:3.8
+ 
+# Set the working directory to /code
+WORKDIR /code
+ 
+# Copy the current directory contents into the container at /code
+COPY ./requirements.txt /code/requirements.txt
+ 
+# Install requirements.txt 
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+ 
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+# Switch to the "user" user
+USER user
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+ 
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+ 
+# Copy the current directory contents into the container at $HOME/app setting the owner to the user
+COPY --chown=user . $HOME/app
+ 
+# Start the FastAPI app on port 7860, the default port expected by Spaces
+# CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+
+CMD gunicorn -k uvicorn.workers.UvicornWorker --workers 2 --threads=2 --max-requests 512 --bind 0.0.0.0:7860 app:app

app.py

@@ -0,0 +1,141 @@
+from fastapi import FastAPI
+import os
+from typing import Any, Union,Dict, List
+import numpy as np
+import io
+import base64
+import requests
+
+import cv2
+from PIL import Image
+ 
+# Create a new FastAPI app instance
+app = FastAPI()
+ 
+# Initialize the text generation pipeline
+# This function will be able to generate text
+# given an input.
+prototxtPath = os.path.sep.join(["face_detector", "deploy.prototxt"])
+weightsPath = os.path.sep.join(["face_detector",
+    "res10_300x300_ssd_iter_140000.caffemodel"])
+net = cv2.dnn.readNet(prototxtPath, weightsPath)
+
+# Define a function to handle the GET request at `/generate`
+# The generate() function is defined as a FastAPI route that takes a 
+# string parameter called text. The function generates text based on the # input using the pipeline() object, and returns a JSON response 
+# containing the generated text under the key "output"
+args = {
+    "method": "simple",
+    "blocks": 20,
+    "confidence": 0.5
+}
+def anonymize_face_simple(image, factor=3.0):
+    # automatically determine the size of the blurring kernel based
+    # on the spatial dimensions of the input image
+    (h, w) = image.shape[:2]
+    kW = int(w / factor)
+    kH = int(h / factor)
+
+    # ensure the width of the kernel is odd
+    if kW % 2 == 0:
+        kW -= 1
+
+    # ensure the height of the kernel is odd
+    if kH % 2 == 0:
+        kH -= 1
+
+    # apply a Gaussian blur to the input image using our computed
+    # kernel size
+    return cv2.GaussianBlur(image, (kW, kH), 0)
+
+def anonymize_face_pixelate(image, blocks=3):
+    # divide the input image into NxN blocks
+    (h, w) = image.shape[:2]
+    xSteps = np.linspace(0, w, blocks + 1, dtype="int")
+    ySteps = np.linspace(0, h, blocks + 1, dtype="int")
+
+    # loop over the blocks in both the x and y direction
+    for i in range(1, len(ySteps)):
+        for j in range(1, len(xSteps)):
+            # compute the starting and ending (x, y)-coordinates
+            # for the current block
+            startX = xSteps[j - 1]
+            startY = ySteps[i - 1]
+            endX = xSteps[j]
+            endY = ySteps[i]
+
+            # extract the ROI using NumPy array slicing, compute the
+            # mean of the ROI, and then draw a rectangle with the
+            # mean RGB values over the ROI in the original image
+            roi = image[startY:endY, startX:endX]
+            (B, G, R) = [int(x) for x in cv2.mean(roi)[:3]]
+            cv2.rectangle(image, (startX, startY), (endX, endY),
+                (B, G, R), -1)
+
+    # return the pixelated blurred image
+    return image
+        
+@app.get("/generate")
+def generate(path: str):
+    """
+    Using the text summarization pipeline from `transformers`, summerize text
+    from the given input text. The model used is `philschmid/bart-large-cnn-samsum`, which
+    can be found [here](<https://huggingface.co/philschmid/bart-large-cnn-samsum>).
+    """
+    r = requests.get(path, stream=True)
+    img = Image.open(io.BytesIO(r.content)).convert('RGB') 
+    open_cv_image = np.array(img) 
+    # Convert RGB to BGR 
+    open_cv_image = open_cv_image[:, :, ::-1].copy()  # numpy array (width, hight, 3)
+    image = open_cv_image # numpy array (width, hight, 3)
+    orig = image.copy()
+    (h, w) = image.shape[:2]
+
+    # construct a blob from the image
+    blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300),(104.0, 177.0, 123.0))
+
+    # pass the blob through the network and obtain the face detections
+    logger.info("computing face detections...")
+    net.setInput(blob)
+    detections = net.forward()
+
+    # loop over the detections
+    for i in range(0, detections.shape[2]):
+        # extract the confidence (i.e., probability) associated with the
+        # detection
+        confidence = detections[0, 0, i, 2]
+
+        # filter out weak detections by ensuring the confidence is greater
+        # than the minimum confidence
+        if confidence > args["confidence"]:
+            # compute the (x, y)-coordinates of the bounding box for the
+            # object
+            box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
+            (startX, startY, endX, endY) = box.astype("int")
+
+            # extract the face ROI
+            face = image[startY:endY, startX:endX]
+
+            # check to see if we are applying the "simple" face blurring
+            # method
+            if args["method"] == "simple":
+                face = anonymize_face_simple(face, factor=3.0)
+
+            # otherwise, we must be applying the "pixelated" face
+            # anonymization method
+            else:
+                face = anonymize_face_pixelate(face,blocks=args["blocks"])
+
+            # store the blurred face in the output image
+            image[startY:endY, startX:endX] = face
+
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    img = Image.fromarray(image)
+
+    im_file = io.BytesIO()
+    img.save(im_file, format="PNG")
+    im_bytes = base64.b64encode(im_file.getvalue()).decode("utf-8") 
+     
+    # Return the generated text in a JSON response
+    return {"output": im_bytes}
+

requirements.txt

@@ -0,0 +1,10 @@
+opencv-python-headless==4.7.0.72
+imageio==2.9.0
+requests==2.27.*
+pandas
+Pillow==7.2.0
+uvloop==0.15.2
+uvicorn==0.13.4
+httptools==0.2.0
+fastapi==0.74.*
+gunicorn==20.1.0