First commit

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.caffemodel filter=lfs diff=lfs merge=lfs -text
+*.prototxt filter=lfs diff=lfs merge=lfs -text

.models/ultra_light_640_batched.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3f7799f40a38a5d726194f881c2981850db5da566a24e7632ff5c92ecaa0137
+size 1574455

app.py

@@ -0,0 +1,316 @@
+import gradio as gr
+import os
+import cv2
+import numpy as np
+import asyncio
+from utils import detect_faces_frame, apply_blur, load_caffe_models
+from ultralight import UltraLightDetector
+import tempfile
+import json
+
+# Create output directories
+os.makedirs("output/image", exist_ok=True)
+os.makedirs("output/video", exist_ok=True)
+os.makedirs("temp", exist_ok=True)
+
+# Initialize detector once
+detector = UltraLightDetector()
+
+# Age and gender options for filters
+AGE_OPTIONS = ['0-2', '4-6', '8-12', '15-20', '25-32', '38-43', '48-53', '60+']
+GENDER_OPTIONS = ['Male', 'Female']
+
+# Operation options
+OPERATION_OPTIONS = {
+    "Gaussian Blur": 0,
+    "Black Patch": 1,
+    "Pixelation": 2
+}
+
+def convert_for_json(obj):
+    """Convert NumPy arrays to lists for JSON serialization"""
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif isinstance(obj, np.float32) or isinstance(obj, np.float64):
+        return float(obj)
+    elif isinstance(obj, np.int32) or isinstance(obj, np.int64):
+        return int(obj)
+    elif isinstance(obj, dict):
+        return {k: convert_for_json(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_for_json(item) for item in obj]
+    else:
+        return obj
+
+def process_image(image, operation_name, age_filters=[], gender_filters=[], selected_face_indices=[]):
+    """Process an image with face blurring"""
+    # Convert from PIL to cv2 format
+    if image is None:
+        return None, "Please upload an image"
+    
+    # Convert from RGB (gradio) to BGR (OpenCV)
+    if isinstance(image, str):  # If it's a path
+        image_cv = cv2.imread(image)
+    else:  # If it's a numpy array
+        image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+    
+    # Get operation code
+    operation = OPERATION_OPTIONS.get(operation_name, 0)
+    
+    # Detect faces
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    predictions = loop.run_until_complete(detect_faces_frame(detector=detector, frame=image_cv))
+    loop.close()
+    
+    # Create a temporary copy for drawing face boxes
+    image_with_boxes = image_cv.copy()
+    
+    # Draw boxes around all detected faces with indices
+    for i, pred in enumerate(predictions):
+        box = np.array(pred['box'])
+        x1, y1, x2, y2 = box.astype(int)
+        # Draw box
+        cv2.rectangle(image_with_boxes, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        # Draw index
+        cv2.putText(image_with_boxes, f"#{i}: {pred['gender']}, {pred['age']}", 
+                   (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+    
+    # Convert to RGB for display
+    image_with_boxes_rgb = cv2.cvtColor(image_with_boxes, cv2.COLOR_BGR2RGB)
+    
+    # Create filters dictionary
+    filters = {
+        "gender": gender_filters,
+        "age": age_filters
+    }
+    
+    # Create selected_faces list based on indices
+    selected_faces = []
+    if selected_face_indices:
+        indices = [int(idx.strip()) for idx in selected_face_indices.split(",") if idx.strip().isdigit()]
+        for i in indices:
+            if i < len(predictions):
+                selected_faces.append({"box": predictions[i]["box"]})
+    
+    # Apply blur
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    processed_image = loop.run_until_complete(
+        apply_blur(
+            detected_faces=predictions,
+            frame=image_cv.copy(),
+            filters=filters,
+            selected_faces=selected_faces,
+            operation=operation
+        )
+    )
+    loop.close()
+    
+    # Convert back to RGB for Gradio
+    processed_image_rgb = cv2.cvtColor(processed_image, cv2.COLOR_BGR2RGB)
+    
+    # Save results as JSON
+    results_data = {
+        "faces_detected": len(predictions),
+        "predictions": convert_for_json(predictions),
+        "operation": operation_name,
+        "filters": {
+            "gender": gender_filters,
+            "age": age_filters
+        },
+        "selected_faces": [int(idx.strip()) for idx in selected_face_indices.split(",") if idx.strip().isdigit()] if selected_face_indices else []
+    }
+    
+    return [image_with_boxes_rgb, processed_image_rgb, json.dumps(results_data, indent=2)]
+
+def process_video(video_path, operation_name, age_filters=[], gender_filters=[], progress=gr.Progress()):
+    """Process a video with face blurring"""
+    if video_path is None:
+        return None, "Please upload a video"
+    
+    # Get operation code
+    operation = OPERATION_OPTIONS.get(operation_name, 0)
+    
+    # Create a temporary file for the output
+    output_path = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name
+    
+    # Open the video
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return None, "Could not open video file"
+    
+    # Get video properties
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    
+    # Determine frame skipping (process every nth frame for speed)
+    frame_skip = max(1, round(fps / 15))  # Process at most 15 fps
+    
+    # Create VideoWriter object
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    
+    # Create filters dictionary
+    filters = {
+        "gender": gender_filters,
+        "age": age_filters
+    }
+    
+    # Process frames
+    frame_count = 0
+    face_count = 0
+    
+    # Process limited frames to prevent timeout (Gradio has a 60s limit by default)
+    max_frames_to_process = min(300, total_frames)  # Limit to 300 frames
+    
+    for _ in progress.tqdm(range(max_frames_to_process)):
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        # Process every nth frame (for efficiency)
+        if frame_count % frame_skip == 0:
+            # Detect faces
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            predictions = loop.run_until_complete(detect_faces_frame(detector=detector, frame=frame))
+            loop.close()
+            
+            face_count += len(predictions)
+            
+            # Apply blur
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            processed_frame = loop.run_until_complete(
+                apply_blur(
+                    detected_faces=predictions,
+                    frame=frame,
+                    filters=filters,
+                    operation=operation
+                )
+            )
+            loop.close()
+            
+            # Write processed frame
+            out.write(processed_frame)
+        else:
+            # Write original frame for skipped frames
+            out.write(frame)
+        
+        frame_count += 1
+    
+    # Release resources
+    cap.release()
+    out.release()
+    
+    # Summary message
+    summary = f"Processed {frame_count} frames, detected {face_count} faces"
+    if frame_count < total_frames:
+        summary += f" (limited to first {frame_count} frames out of {total_frames})"
+    
+    return output_path, summary
+
+# Create Gradio interface
+with gr.Blocks(title="Face Privacy Protection Tool") as demo:
+    gr.Markdown("# Face Privacy Protection Tool")
+    gr.Markdown("Upload an image or video to detect faces and apply privacy filters")
+    
+    with gr.Tabs():
+        with gr.TabItem("Image Processing"):
+            with gr.Row():
+                with gr.Column():
+                    image_input = gr.Image(label="Upload Image", type="pil")
+                    operation_dropdown = gr.Dropdown(
+                        choices=list(OPERATION_OPTIONS.keys()),
+                        value="Gaussian Blur",
+                        label="Blur Operation"
+                    )
+                    
+                    with gr.Accordion("Advanced Filtering", open=False):
+                        age_filter = gr.CheckboxGroup(
+                            choices=AGE_OPTIONS,
+                            label="Filter by Age (select to blur)"
+                        )
+                        gender_filter = gr.CheckboxGroup(
+                            choices=GENDER_OPTIONS,
+                            label="Filter by Gender (select to blur)"
+                        )
+                        selected_faces = gr.Textbox(
+                            label="Select Specific Faces to Blur (comma-separated indices, e.g., 0,1,3)",
+                            placeholder="Enter face indices separated by commas"
+                        )
+                    
+                    image_button = gr.Button("Process Image")
+                
+                with gr.Column():
+                    output_tabs = gr.Tabs()
+                    with output_tabs:
+                        with gr.TabItem("Face Detection"):
+                            image_with_boxes = gr.Image(label="Detected Faces")
+                        
+                        with gr.TabItem("Processed Image"):
+                            image_output = gr.Image(label="Processed Image")
+                        
+                        with gr.TabItem("JSON Results"):
+                            json_output = gr.JSON(label="Detection Results")
+            
+            image_button.click(
+                process_image,
+                inputs=[image_input, operation_dropdown, age_filter, gender_filter, selected_faces],
+                outputs=[image_with_boxes, image_output, json_output]
+            )
+        
+        with gr.TabItem("Video Processing"):
+            with gr.Row():
+                with gr.Column():
+                    video_input = gr.Video(label="Upload Video")
+                    video_operation = gr.Dropdown(
+                        choices=list(OPERATION_OPTIONS.keys()),
+                        value="Gaussian Blur",
+                        label="Blur Operation"
+                    )
+                    
+                    with gr.Accordion("Advanced Filtering", open=False):
+                        video_age_filter = gr.CheckboxGroup(
+                            choices=AGE_OPTIONS,
+                            label="Filter by Age (select to blur)"
+                        )
+                        video_gender_filter = gr.CheckboxGroup(
+                            choices=GENDER_OPTIONS,
+                            label="Filter by Gender (select to blur)"
+                        )
+                    
+                    video_button = gr.Button("Process Video")
+                
+                with gr.Column():
+                    video_output = gr.Video(label="Processed Video")
+                    video_summary = gr.Textbox(label="Processing Summary")
+            
+            video_button.click(
+                process_video,
+                inputs=[video_input, video_operation, video_age_filter, video_gender_filter],
+                outputs=[video_output, video_summary]
+            )
+    
+    gr.Markdown("""
+    ## How to Use
+    
+    1. **Upload** an image or video using the respective tab
+    2. **Choose** your preferred blur operation:
+       - **Gaussian Blur**: Blurs facial features while maintaining face shape
+       - **Black Patch**: Completely covers faces with black rectangles
+       - **Pixelation**: Creates a mosaic effect over faces
+    3. **Advanced Filtering**:
+       - Filter by age group (select which age groups to blur)
+       - Filter by gender (select which genders to blur)
+       - For images, you can select specific face indices to blur
+    4. **Process** the media and view the results
+    
+    Note: Video processing may take some time depending on the file size.
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

opencv_models/age_deploy.prototxt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5e443b19e5ca4b6dd213f7a0bfbf03cde25e649708a2fccb65b843966da0c13
+size 2481

opencv_models/age_net.caffemodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dde5d07df5ca1d66ff39e525693f05ccfb9d2c437e188fdd1a10d42e57fabd6
+size 45661480

opencv_models/gender_deploy.prototxt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91f2ec19a1fbca8ede5d4b9ef6e60be85b3a976aaf5b50fa9a96d3e4b61a90a2
+size 2482

opencv_models/gender_net.caffemodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac7571b281ae078817764b645a20541bd6aa1babeac20a45e6d8de7d61ba0e50
+size 45649168

opencv_models/opencv_face_detector.pbtxt

@@ -0,0 +1,2362 @@
+node {
+  name: "data"
+  op: "Placeholder"
+  attr {
+    key: "dtype"
+    value {
+      type: DT_FLOAT
+    }
+  }
+}
+node {
+  name: "data_bn/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "data:0"
+  input: "data_bn/gamma"
+  input: "data_bn/beta"
+  input: "data_bn/mean"
+  input: "data_bn/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "data_scale/Mul"
+  op: "Mul"
+  input: "data_bn/FusedBatchNorm"
+  input: "data_scale/mul"
+}
+node {
+  name: "data_scale/BiasAdd"
+  op: "BiasAdd"
+  input: "data_scale/Mul"
+  input: "data_scale/add"
+}
+node {
+  name: "SpaceToBatchND/block_shape"
+  op: "Const"
+  attr {
+    key: "value"
+    value {
+      tensor {
+        dtype: DT_INT32
+        tensor_shape {
+          dim {
+            size: 2
+          }
+        }
+        int_val: 1
+        int_val: 1
+      }
+    }
+  }
+}
+node {
+  name: "SpaceToBatchND/paddings"
+  op: "Const"
+  attr {
+    key: "value"
+    value {
+      tensor {
+        dtype: DT_INT32
+        tensor_shape {
+          dim {
+            size: 2
+          }
+          dim {
+            size: 2
+          }
+        }
+        int_val: 3
+        int_val: 3
+        int_val: 3
+        int_val: 3
+      }
+    }
+  }
+}
+node {
+  name: "Pad"
+  op: "SpaceToBatchND"
+  input: "data_scale/BiasAdd"
+  input: "SpaceToBatchND/block_shape"
+  input: "SpaceToBatchND/paddings"
+}
+node {
+  name: "conv1_h/Conv2D"
+  op: "Conv2D"
+  input: "Pad"
+  input: "conv1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv1_h/Conv2D"
+  input: "conv1_h/bias"
+}
+node {
+  name: "BatchToSpaceND"
+  op: "BatchToSpaceND"
+  input: "conv1_h/BiasAdd"
+}
+node {
+  name: "conv1_bn_h/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "BatchToSpaceND"
+  input: "conv1_bn_h/gamma"
+  input: "conv1_bn_h/beta"
+  input: "conv1_bn_h/mean"
+  input: "conv1_bn_h/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "conv1_scale_h/Mul"
+  op: "Mul"
+  input: "conv1_bn_h/FusedBatchNorm"
+  input: "conv1_scale_h/mul"
+}
+node {
+  name: "conv1_scale_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv1_scale_h/Mul"
+  input: "conv1_scale_h/add"
+}
+node {
+  name: "Relu"
+  op: "Relu"
+  input: "conv1_scale_h/BiasAdd"
+}
+node {
+  name: "conv1_pool/MaxPool"
+  op: "MaxPool"
+  input: "Relu"
+  attr {
+    key: "ksize"
+    value {
+      list {
+        i: 1
+        i: 3
+        i: 3
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_64_1_conv1_h/Conv2D"
+  op: "Conv2D"
+  input: "conv1_pool/MaxPool"
+  input: "layer_64_1_conv1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_64_1_bn2_h/FusedBatchNorm"
+  op: "BiasAdd"
+  input: "layer_64_1_conv1_h/Conv2D"
+  input: "layer_64_1_conv1_h/Conv2D_bn_offset"
+}
+node {
+  name: "layer_64_1_scale2_h/Mul"
+  op: "Mul"
+  input: "layer_64_1_bn2_h/FusedBatchNorm"
+  input: "layer_64_1_scale2_h/mul"
+}
+node {
+  name: "layer_64_1_scale2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_64_1_scale2_h/Mul"
+  input: "layer_64_1_scale2_h/add"
+}
+node {
+  name: "Relu_1"
+  op: "Relu"
+  input: "layer_64_1_scale2_h/BiasAdd"
+}
+node {
+  name: "layer_64_1_conv2_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_1"
+  input: "layer_64_1_conv2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "add"
+  op: "Add"
+  input: "layer_64_1_conv2_h/Conv2D"
+  input: "conv1_pool/MaxPool"
+}
+node {
+  name: "layer_128_1_bn1_h/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "add"
+  input: "layer_128_1_bn1_h/gamma"
+  input: "layer_128_1_bn1_h/beta"
+  input: "layer_128_1_bn1_h/mean"
+  input: "layer_128_1_bn1_h/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "layer_128_1_scale1_h/Mul"
+  op: "Mul"
+  input: "layer_128_1_bn1_h/FusedBatchNorm"
+  input: "layer_128_1_scale1_h/mul"
+}
+node {
+  name: "layer_128_1_scale1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_128_1_scale1_h/Mul"
+  input: "layer_128_1_scale1_h/add"
+}
+node {
+  name: "Relu_2"
+  op: "Relu"
+  input: "layer_128_1_scale1_h/BiasAdd"
+}
+node {
+  name: "layer_128_1_conv_expand_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_2"
+  input: "layer_128_1_conv_expand_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_128_1_conv1_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_2"
+  input: "layer_128_1_conv1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_128_1_bn2/FusedBatchNorm"
+  op: "BiasAdd"
+  input: "layer_128_1_conv1_h/Conv2D"
+  input: "layer_128_1_conv1_h/Conv2D_bn_offset"
+}
+node {
+  name: "layer_128_1_scale2/Mul"
+  op: "Mul"
+  input: "layer_128_1_bn2/FusedBatchNorm"
+  input: "layer_128_1_scale2/mul"
+}
+node {
+  name: "layer_128_1_scale2/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_128_1_scale2/Mul"
+  input: "layer_128_1_scale2/add"
+}
+node {
+  name: "Relu_3"
+  op: "Relu"
+  input: "layer_128_1_scale2/BiasAdd"
+}
+node {
+  name: "layer_128_1_conv2/Conv2D"
+  op: "Conv2D"
+  input: "Relu_3"
+  input: "layer_128_1_conv2/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "add_1"
+  op: "Add"
+  input: "layer_128_1_conv2/Conv2D"
+  input: "layer_128_1_conv_expand_h/Conv2D"
+}
+node {
+  name: "layer_256_1_bn1/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "add_1"
+  input: "layer_256_1_bn1/gamma"
+  input: "layer_256_1_bn1/beta"
+  input: "layer_256_1_bn1/mean"
+  input: "layer_256_1_bn1/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "layer_256_1_scale1/Mul"
+  op: "Mul"
+  input: "layer_256_1_bn1/FusedBatchNorm"
+  input: "layer_256_1_scale1/mul"
+}
+node {
+  name: "layer_256_1_scale1/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_256_1_scale1/Mul"
+  input: "layer_256_1_scale1/add"
+}
+node {
+  name: "Relu_4"
+  op: "Relu"
+  input: "layer_256_1_scale1/BiasAdd"
+}
+node {
+  name: "SpaceToBatchND_1/paddings"
+  op: "Const"
+  attr {
+    key: "value"
+    value {
+      tensor {
+        dtype: DT_INT32
+        tensor_shape {
+          dim {
+            size: 2
+          }
+          dim {
+            size: 2
+          }
+        }
+        int_val: 1
+        int_val: 1
+        int_val: 1
+        int_val: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_256_1_conv_expand/Conv2D"
+  op: "Conv2D"
+  input: "Relu_4"
+  input: "layer_256_1_conv_expand/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv4_3_norm/l2_normalize"
+  op: "L2Normalize"
+  input: "Relu_4:0"
+  input: "conv4_3_norm/l2_normalize/Sum/reduction_indices"
+}
+node {
+  name: "conv4_3_norm/mul_1"
+  op: "Mul"
+  input: "conv4_3_norm/l2_normalize"
+  input: "conv4_3_norm/mul"
+}
+node {
+  name: "conv4_3_norm_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv4_3_norm/mul_1"
+  input: "conv4_3_norm_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv4_3_norm_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv4_3_norm_mbox_loc/Conv2D"
+  input: "conv4_3_norm_mbox_loc/bias"
+}
+node {
+  name: "flatten/Reshape"
+  op: "Flatten"
+  input: "conv4_3_norm_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv4_3_norm_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv4_3_norm/mul_1"
+  input: "conv4_3_norm_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv4_3_norm_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv4_3_norm_mbox_conf/Conv2D"
+  input: "conv4_3_norm_mbox_conf/bias"
+}
+node {
+  name: "flatten_6/Reshape"
+  op: "Flatten"
+  input: "conv4_3_norm_mbox_conf/BiasAdd"
+}
+node {
+  name: "Pad_1"
+  op: "SpaceToBatchND"
+  input: "Relu_4"
+  input: "SpaceToBatchND/block_shape"
+  input: "SpaceToBatchND_1/paddings"
+}
+node {
+  name: "layer_256_1_conv1/Conv2D"
+  op: "Conv2D"
+  input: "Pad_1"
+  input: "layer_256_1_conv1/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_256_1_bn2/FusedBatchNorm"
+  op: "BiasAdd"
+  input: "layer_256_1_conv1/Conv2D"
+  input: "layer_256_1_conv1/Conv2D_bn_offset"
+}
+node {
+  name: "BatchToSpaceND_1"
+  op: "BatchToSpaceND"
+  input: "layer_256_1_bn2/FusedBatchNorm"
+}
+node {
+  name: "layer_256_1_scale2/Mul"
+  op: "Mul"
+  input: "BatchToSpaceND_1"
+  input: "layer_256_1_scale2/mul"
+}
+node {
+  name: "layer_256_1_scale2/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_256_1_scale2/Mul"
+  input: "layer_256_1_scale2/add"
+}
+node {
+  name: "Relu_5"
+  op: "Relu"
+  input: "layer_256_1_scale2/BiasAdd"
+}
+node {
+  name: "layer_256_1_conv2/Conv2D"
+  op: "Conv2D"
+  input: "Relu_5"
+  input: "layer_256_1_conv2/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "add_2"
+  op: "Add"
+  input: "layer_256_1_conv2/Conv2D"
+  input: "layer_256_1_conv_expand/Conv2D"
+}
+node {
+  name: "layer_512_1_bn1/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "add_2"
+  input: "layer_512_1_bn1/gamma"
+  input: "layer_512_1_bn1/beta"
+  input: "layer_512_1_bn1/mean"
+  input: "layer_512_1_bn1/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "layer_512_1_scale1/Mul"
+  op: "Mul"
+  input: "layer_512_1_bn1/FusedBatchNorm"
+  input: "layer_512_1_scale1/mul"
+}
+node {
+  name: "layer_512_1_scale1/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_512_1_scale1/Mul"
+  input: "layer_512_1_scale1/add"
+}
+node {
+  name: "Relu_6"
+  op: "Relu"
+  input: "layer_512_1_scale1/BiasAdd"
+}
+node {
+  name: "layer_512_1_conv_expand_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_6"
+  input: "layer_512_1_conv_expand_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_512_1_conv1_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_6"
+  input: "layer_512_1_conv1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_512_1_bn2_h/FusedBatchNorm"
+  op: "BiasAdd"
+  input: "layer_512_1_conv1_h/Conv2D"
+  input: "layer_512_1_conv1_h/Conv2D_bn_offset"
+}
+node {
+  name: "layer_512_1_scale2_h/Mul"
+  op: "Mul"
+  input: "layer_512_1_bn2_h/FusedBatchNorm"
+  input: "layer_512_1_scale2_h/mul"
+}
+node {
+  name: "layer_512_1_scale2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_512_1_scale2_h/Mul"
+  input: "layer_512_1_scale2_h/add"
+}
+node {
+  name: "Relu_7"
+  op: "Relu"
+  input: "layer_512_1_scale2_h/BiasAdd"
+}
+node {
+  name: "layer_512_1_conv2_h/convolution/SpaceToBatchND"
+  op: "SpaceToBatchND"
+  input: "Relu_7"
+  input: "layer_512_1_conv2_h/convolution/SpaceToBatchND/block_shape"
+  input: "layer_512_1_conv2_h/convolution/SpaceToBatchND/paddings"
+}
+node {
+  name: "layer_512_1_conv2_h/convolution"
+  op: "Conv2D"
+  input: "layer_512_1_conv2_h/convolution/SpaceToBatchND"
+  input: "layer_512_1_conv2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_512_1_conv2_h/convolution/BatchToSpaceND"
+  op: "BatchToSpaceND"
+  input: "layer_512_1_conv2_h/convolution"
+  input: "layer_512_1_conv2_h/convolution/BatchToSpaceND/block_shape"
+  input: "layer_512_1_conv2_h/convolution/BatchToSpaceND/crops"
+}
+node {
+  name: "add_3"
+  op: "Add"
+  input: "layer_512_1_conv2_h/convolution/BatchToSpaceND"
+  input: "layer_512_1_conv_expand_h/Conv2D"
+}
+node {
+  name: "last_bn_h/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "add_3"
+  input: "last_bn_h/gamma"
+  input: "last_bn_h/beta"
+  input: "last_bn_h/mean"
+  input: "last_bn_h/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "last_scale_h/Mul"
+  op: "Mul"
+  input: "last_bn_h/FusedBatchNorm"
+  input: "last_scale_h/mul"
+}
+node {
+  name: "last_scale_h/BiasAdd"
+  op: "BiasAdd"
+  input: "last_scale_h/Mul"
+  input: "last_scale_h/add"
+}
+node {
+  name: "last_relu"
+  op: "Relu"
+  input: "last_scale_h/BiasAdd"
+}
+node {
+  name: "conv6_1_h/Conv2D"
+  op: "Conv2D"
+  input: "last_relu"
+  input: "conv6_1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv6_1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv6_1_h/Conv2D"
+  input: "conv6_1_h/bias"
+}
+node {
+  name: "conv6_1_h/Relu"
+  op: "Relu"
+  input: "conv6_1_h/BiasAdd"
+}
+node {
+  name: "conv6_2_h/Conv2D"
+  op: "Conv2D"
+  input: "conv6_1_h/Relu"
+  input: "conv6_2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv6_2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv6_2_h/Conv2D"
+  input: "conv6_2_h/bias"
+}
+node {
+  name: "conv6_2_h/Relu"
+  op: "Relu"
+  input: "conv6_2_h/BiasAdd"
+}
+node {
+  name: "conv7_1_h/Conv2D"
+  op: "Conv2D"
+  input: "conv6_2_h/Relu"
+  input: "conv7_1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv7_1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv7_1_h/Conv2D"
+  input: "conv7_1_h/bias"
+}
+node {
+  name: "conv7_1_h/Relu"
+  op: "Relu"
+  input: "conv7_1_h/BiasAdd"
+}
+node {
+  name: "Pad_2"
+  op: "SpaceToBatchND"
+  input: "conv7_1_h/Relu"
+  input: "SpaceToBatchND/block_shape"
+  input: "SpaceToBatchND_1/paddings"
+}
+node {
+  name: "conv7_2_h/Conv2D"
+  op: "Conv2D"
+  input: "Pad_2"
+  input: "conv7_2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv7_2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv7_2_h/Conv2D"
+  input: "conv7_2_h/bias"
+}
+node {
+  name: "BatchToSpaceND_2"
+  op: "BatchToSpaceND"
+  input: "conv7_2_h/BiasAdd"
+}
+node {
+  name: "conv7_2_h/Relu"
+  op: "Relu"
+  input: "BatchToSpaceND_2"
+}
+node {
+  name: "conv8_1_h/Conv2D"
+  op: "Conv2D"
+  input: "conv7_2_h/Relu"
+  input: "conv8_1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv8_1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv8_1_h/Conv2D"
+  input: "conv8_1_h/bias"
+}
+node {
+  name: "conv8_1_h/Relu"
+  op: "Relu"
+  input: "conv8_1_h/BiasAdd"
+}
+node {
+  name: "conv8_2_h/Conv2D"
+  op: "Conv2D"
+  input: "conv8_1_h/Relu"
+  input: "conv8_2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv8_2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv8_2_h/Conv2D"
+  input: "conv8_2_h/bias"
+}
+node {
+  name: "conv8_2_h/Relu"
+  op: "Relu"
+  input: "conv8_2_h/BiasAdd"
+}
+node {
+  name: "conv9_1_h/Conv2D"
+  op: "Conv2D"
+  input: "conv8_2_h/Relu"
+  input: "conv9_1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv9_1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv9_1_h/Conv2D"
+  input: "conv9_1_h/bias"
+}
+node {
+  name: "conv9_1_h/Relu"
+  op: "Relu"
+  input: "conv9_1_h/BiasAdd"
+}
+node {
+  name: "conv9_2_h/Conv2D"
+  op: "Conv2D"
+  input: "conv9_1_h/Relu"
+  input: "conv9_2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv9_2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv9_2_h/Conv2D"
+  input: "conv9_2_h/bias"
+}
+node {
+  name: "conv9_2_h/Relu"
+  op: "Relu"
+  input: "conv9_2_h/BiasAdd"
+}
+node {
+  name: "conv9_2_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv9_2_h/Relu"
+  input: "conv9_2_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv9_2_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv9_2_mbox_loc/Conv2D"
+  input: "conv9_2_mbox_loc/bias"
+}
+node {
+  name: "flatten_5/Reshape"
+  op: "Flatten"
+  input: "conv9_2_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv9_2_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv9_2_h/Relu"
+  input: "conv9_2_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv9_2_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv9_2_mbox_conf/Conv2D"
+  input: "conv9_2_mbox_conf/bias"
+}
+node {
+  name: "flatten_11/Reshape"
+  op: "Flatten"
+  input: "conv9_2_mbox_conf/BiasAdd"
+}
+node {
+  name: "conv8_2_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv8_2_h/Relu"
+  input: "conv8_2_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv8_2_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv8_2_mbox_loc/Conv2D"
+  input: "conv8_2_mbox_loc/bias"
+}
+node {
+  name: "flatten_4/Reshape"
+  op: "Flatten"
+  input: "conv8_2_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv8_2_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv8_2_h/Relu"
+  input: "conv8_2_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv8_2_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv8_2_mbox_conf/Conv2D"
+  input: "conv8_2_mbox_conf/bias"
+}
+node {
+  name: "flatten_10/Reshape"
+  op: "Flatten"
+  input: "conv8_2_mbox_conf/BiasAdd"
+}
+node {
+  name: "conv7_2_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv7_2_h/Relu"
+  input: "conv7_2_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv7_2_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv7_2_mbox_loc/Conv2D"
+  input: "conv7_2_mbox_loc/bias"
+}
+node {
+  name: "flatten_3/Reshape"
+  op: "Flatten"
+  input: "conv7_2_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv7_2_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv7_2_h/Relu"
+  input: "conv7_2_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv7_2_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv7_2_mbox_conf/Conv2D"
+  input: "conv7_2_mbox_conf/bias"
+}
+node {
+  name: "flatten_9/Reshape"
+  op: "Flatten"
+  input: "conv7_2_mbox_conf/BiasAdd"
+}
+node {
+  name: "conv6_2_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv6_2_h/Relu"
+  input: "conv6_2_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv6_2_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv6_2_mbox_loc/Conv2D"
+  input: "conv6_2_mbox_loc/bias"
+}
+node {
+  name: "flatten_2/Reshape"
+  op: "Flatten"
+  input: "conv6_2_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv6_2_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv6_2_h/Relu"
+  input: "conv6_2_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv6_2_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv6_2_mbox_conf/Conv2D"
+  input: "conv6_2_mbox_conf/bias"
+}
+node {
+  name: "flatten_8/Reshape"
+  op: "Flatten"
+  input: "conv6_2_mbox_conf/BiasAdd"
+}
+node {
+  name: "fc7_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "last_relu"
+  input: "fc7_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "fc7_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "fc7_mbox_loc/Conv2D"
+  input: "fc7_mbox_loc/bias"
+}
+node {
+  name: "flatten_1/Reshape"
+  op: "Flatten"
+  input: "fc7_mbox_loc/BiasAdd"
+}
+node {
+  name: "mbox_loc"
+  op: "ConcatV2"
+  input: "flatten/Reshape"
+  input: "flatten_1/Reshape"
+  input: "flatten_2/Reshape"
+  input: "flatten_3/Reshape"
+  input: "flatten_4/Reshape"
+  input: "flatten_5/Reshape"
+  input: "mbox_loc/axis"
+}
+node {
+  name: "fc7_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "last_relu"
+  input: "fc7_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "fc7_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "fc7_mbox_conf/Conv2D"
+  input: "fc7_mbox_conf/bias"
+}
+node {
+  name: "flatten_7/Reshape"
+  op: "Flatten"
+  input: "fc7_mbox_conf/BiasAdd"
+}
+node {
+  name: "mbox_conf"
+  op: "ConcatV2"
+  input: "flatten_6/Reshape"
+  input: "flatten_7/Reshape"
+  input: "flatten_8/Reshape"
+  input: "flatten_9/Reshape"
+  input: "flatten_10/Reshape"
+  input: "flatten_11/Reshape"
+  input: "mbox_conf/axis"
+}
+node {
+  name: "mbox_conf_reshape"
+  op: "Reshape"
+  input: "mbox_conf"
+  input: "reshape_before_softmax"
+}
+node {
+  name: "mbox_conf_softmax"
+  op: "Softmax"
+  input: "mbox_conf_reshape"
+  attr {
+    key: "axis"
+    value {
+      i: 2
+    }
+  }
+}
+node {
+  name: "mbox_conf_flatten"
+  op: "Flatten"
+  input: "mbox_conf_softmax"
+}
+node {
+  name: "PriorBox_0"
+  op: "PriorBox"
+  input: "conv4_3_norm/mul_1"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 1
+          }
+        }
+        float_val: 2.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 60
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 30
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 8.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_1"
+  op: "PriorBox"
+  input: "last_relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 2
+          }
+        }
+        float_val: 2.0
+        float_val: 3.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 111
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 60
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 16.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_2"
+  op: "PriorBox"
+  input: "conv6_2_h/Relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 2
+          }
+        }
+        float_val: 2.0
+        float_val: 3.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 162
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 111
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 32.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_3"
+  op: "PriorBox"
+  input: "conv7_2_h/Relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 2
+          }
+        }
+        float_val: 2.0
+        float_val: 3.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 213
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 162
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 64.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_4"
+  op: "PriorBox"
+  input: "conv8_2_h/Relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 1
+          }
+        }
+        float_val: 2.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 264
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 213
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 100.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_5"
+  op: "PriorBox"
+  input: "conv9_2_h/Relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 1
+          }
+        }
+        float_val: 2.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 315
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 264
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 300.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "mbox_priorbox"
+  op: "ConcatV2"
+  input: "PriorBox_0"
+  input: "PriorBox_1"
+  input: "PriorBox_2"
+  input: "PriorBox_3"
+  input: "PriorBox_4"
+  input: "PriorBox_5"
+  input: "mbox_loc/axis"
+}
+node {
+  name: "detection_out"
+  op: "DetectionOutput"
+  input: "mbox_loc"
+  input: "mbox_conf_flatten"
+  input: "mbox_priorbox"
+  attr {
+    key: "background_label_id"
+    value {
+      i: 0
+    }
+  }
+  attr {
+    key: "code_type"
+    value {
+      s: "CENTER_SIZE"
+    }
+  }
+  attr {
+    key: "confidence_threshold"
+    value {
+      f: 0.00999999977648
+    }
+  }
+  attr {
+    key: "keep_top_k"
+    value {
+      i: 200
+    }
+  }
+  attr {
+    key: "nms_threshold"
+    value {
+      f: 0.449999988079
+    }
+  }
+  attr {
+    key: "num_classes"
+    value {
+      i: 2
+    }
+  }
+  attr {
+    key: "share_location"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "top_k"
+    value {
+      i: 400
+    }
+  }
+}
+node {
+  name: "reshape_before_softmax"
+  op: "Const"
+  attr {
+    key: "value"
+    value {
+      tensor {
+        dtype: DT_INT32
+        tensor_shape {
+          dim {
+            size: 3
+          }
+        }
+        int_val: 0
+        int_val: -1
+        int_val: 2
+      }
+    }
+  }
+}
+library {
+}

opencv_models/opencv_face_detector_uint8.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c71d752ef2cbf2f457ac82fdd580fcb2522fd04c5efdaed18eb6d9e2843fbed
+size 2727750

requirements.txt

@@ -0,0 +1,9 @@
+opencv-python==4.8.1.78
+numpy<2
+gradio>=4.0.0
+Pillow>=9.0.0
+ultralight>=0.1.0
+onnxruntime==1.14.1
+matplotlib>=3.5.0
+pyyaml>=6.0
+tqdm>=4.65.0

utils.py

@@ -0,0 +1,238 @@
+import cv2
+from ultralight import UltraLightDetector
+from ultralight.utils import draw_faces
+import time
+import asyncio
+
+def load_caffe_models():
+    age_net = cv2.dnn.readNet(
+        r"opencv_models\age_net.caffemodel",
+        r"opencv_models\age_deploy.prototxt"
+    )
+    gender_net = cv2.dnn.readNet(
+        r"opencv_models\gender_net.caffemodel",
+        r"opencv_models\gender_deploy.prototxt"
+    )
+    
+    return age_net, gender_net
+
+async def detect_faces_frame(detector, frame=None):
+    if frame is None:
+        print("No frames obtained!")
+        return list()
+    else:
+        # define age and gender list
+        age_list = ['0-2', '4-6', '8-12', '15-20', '25-32', '38-43', '48-53', '60+']
+        gender_list = ['Male', 'Female']
+        
+        # detect the faces and load age & gender detection models
+        boxes, scores = detector.detect_one(frame)
+        age_model, gender_model = load_caffe_models()
+        
+        results = []
+        
+        for i, box in enumerate(boxes):
+            x1, y1, x2, y2 = box.astype(int)
+            padding = int((x2 - x1) * 0.2)
+            height, width = frame.shape[:2]
+            
+            x1_pad = max(0, x1 - padding)
+            y1_pad = max(0, y1 - padding)
+            x2_pad = min(width, x2 + padding)
+            y2_pad = min(height, y2 + padding)
+            
+            face_img = frame[y1_pad:y2_pad, x1_pad:x2_pad] 
+                
+            if face_img.shape[0] < 10 or face_img.shape[1] < 10:
+                continue
+            blob = cv2.dnn.blobFromImage(
+                face_img, 1.0, (227, 227),
+                (78.4263377603, 87.7689143744, 114.895847746),
+                swapRB=False
+            )
+            gender_model.setInput(blob)
+            gender_preds = gender_model.forward()
+            gender = gender_list[gender_preds[0].argmax()]
+            gender_confidence = float(gender_preds[0].max())
+            
+            age_model.setInput(blob)
+            age_preds = age_model.forward()
+            age = age_list[age_preds[0].argmax()]
+            age_confidence = float(age_preds[0].max())
+            
+            results.append({
+                'index': i,
+                'box': box.tolist(),
+                'score': float(scores[i]),
+                'gender': gender,
+                'gender_confidence': gender_confidence,
+                'age': age,
+                'age_confidence': age_confidence
+            })
+            
+        return results
+
+    
+def apply_black_patch(frame, face_img, color=(0,0,0)):
+    """Apply black patch to face region"""
+    if frame is None or not face_img:
+        return frame
+    x1, y1, x2, y2 = map(int, face_img["box"])
+    frame[y1:y2, x1:x2] = color
+    return frame
+
+def apply_gaussian_blur(frame, face_img, blur_factor=25):
+    """Apply strong Gaussian blur to face region"""
+    if frame is None or not face_img:
+        return frame
+    x1, y1, x2, y2 = map(int, face_img['box'])
+    face_region = frame[y1:y2, x1:x2]
+    
+    # Ensure blur_factor is odd (requirement for GaussianBlur)
+    if blur_factor % 2 == 0:
+        blur_factor += 1
+        
+    # Apply blur
+    blurred = cv2.GaussianBlur(face_region, (blur_factor, blur_factor), 0)
+    frame[y1:y2, x1:x2] = blurred
+
+    return frame
+
+def apply_pixelation(frame, face_img, blocks=8):
+    """Apply pixelation effect to face region"""
+    if frame is None or not face_img:
+        return frame
+    
+    x1, y1, x2, y2 = map(int, face_img['box'])
+    face_region = frame[y1:y2, x1:x2]
+    
+    height, width = face_region.shape[:2]
+    
+    # Create heavy pixelation (small number of blocks = larger pixels)
+    temp = cv2.resize(face_region, (blocks, blocks), interpolation=cv2.INTER_LINEAR)
+    pixelated = cv2.resize(temp, (width, height), interpolation=cv2.INTER_NEAREST)
+    frame[y1:y2, x1:x2] = pixelated
+    return frame
+
+async def apply_blur(
+    detected_faces, # Can not be None, mandatory argument
+    frame=None, 
+    filters=None,
+    selected_faces=[],
+    operation=0, # default Gaussian Blur(High Kernel, blur factor 30); Other values are: 1 -> Black Patch(Simple Occlusion), 2 -> Pixelation(Heavy Mosaicing)
+    output_path_root=None
+):
+    # suppose i'm processing the video, how can i play it while processing it? also, post processing how do i play it? i'd be uing flask as the backend
+    """
+    if filters is None:
+        # blur all faces
+    else:
+        if filters["age"] is None or len(filters["age"]) == 0:
+            # blur faces based on gender
+        elif filters["gender"] is None or len(filters["gender"]) == 0:
+            # blur faces based on age
+        else:
+            # blur faces based on both age and gender
+    
+    # Implement only if you have time
+    if selected_faces is not None:
+        # blur selected_faces
+    """
+
+    if filters is None:
+        # blur all faces
+        for face_img in detected_faces:
+            selected_faces.append({"box": face_img["box"]})
+            
+    else:
+        if len(filters["gender"]) != 0:
+            for face_img in detected_faces:
+                if face_img["gender"] in filters["gender"]:
+                    selected_faces.append({"box": face_img["box"]})
+                
+        if len(filters["age"]) != 0:
+            for face_img in detected_faces:
+                if face_img["age"] in filters["age"]:
+                    selected_faces.append({"box": face_img["box"]})
+    
+    if len(selected_faces) != 0:
+        for face_img in selected_faces:
+            if operation == 0:
+                frame = apply_gaussian_blur(frame, face_img=face_img)
+            elif operation == 1:
+                frame = apply_black_patch(frame, face_img=face_img)
+            elif operation == 2:
+                frame = apply_pixelation(frame, face_img=face_img)
+    
+    return frame
+
+
+async def process_input(
+    image_path=None,
+    video_path=None,
+    output_path_root=None,
+    filters=None,
+    operation=0,
+    selected_faces=[]
+):
+    detector = UltraLightDetector()
+    if image_path is not None:
+        output_path = f"{output_path_root}/image/output_image.jpeg"
+        frame = cv2.imread(image_path)
+        predictions = await detect_faces_frame(frame=frame, detector=detector)
+        frame = await apply_blur(
+            predictions,
+            frame=frame,
+            filters=filters,
+            selected_faces=selected_faces,
+            operation=operation,
+            output_path_root=output_path_root
+        )
+        cv2.imwrite(output_path, frame)
+        print("Output saved successfully!")
+        cv2.imshow("Result Image", frame)
+        cv2.waitKey(0)
+    
+    elif video_path is not None:
+        output_path = f"{output_path_root}/video/output_video.mp4"
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            print(f"Error: Could not open video {video_path}")
+            return [], []
+        
+        org_fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_skip = max(1, round(org_fps / 30))
+        
+        frame_count = 0
+        
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, org_fps, (width, height))
+        all_predictions = []
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            if frame_count % frame_skip == 0:
+                predictions = await detect_faces_frame(frame=frame, detector=detector)
+                all_predictions.append(predictions)
+                
+                out.write(frame)
+                     
+            frame_count += 1
+        cap.release()
+        out.release()
+        print(f"Video processing complete. Output saved to {output_path}")
+    
+    else:
+        print("Error: No input provided")
+    
+    cv2.destroyAllWindows()
+    
+    
+if __name__ == "__main__":
+    image_path = r"D:\hackathons\we_hack_2025\project_anon\trials\teenage_girls.png"
+    output_path_root = r"D:\hackathons\we_hack_2025\project_anon\output"
+    asyncio.run(process_input(image_path=image_path, output_path_root=output_path_root, operation=2))