Upload 4 files

best.onnx

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

dockerfile

@@ -0,0 +1,36 @@
+# Use a base image from Microsoft that includes Conda, Python, and GPU drivers.
+# This image is a great starting point for ML workloads on Azure.
+FROM mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
+
+# Set the working directory inside the container. All subsequent commands
+# will be executed from this directory.
+WORKDIR /app
+
+# Copy the Conda environment file into the container.
+COPY environment.yml .
+
+# Create the Conda environment using the provided YAML file.
+# The name of the environment will be `yolo-onnx-cpu-env` as defined in the file.
+RUN conda env create -f environment.yml
+
+# We need to install `gunicorn` and `Flask` or a similar web server to serve the model.
+# Azure Container Apps uses HTTP to trigger scaling.
+# We'll install these into the new Conda environment.
+SHELL ["conda", "run", "-n", "yolo-onnx-cpu-env", "/bin/bash", "-c"]
+RUN pip install gunicorn flask
+
+# Copy the scoring script, the ONNX model file, and any other necessary files
+# into the container's working directory.
+COPY scoring_Yolo_Model.py .
+COPY best.onnx .
+# Assuming `class_names` or other static files are also present, copy them here.
+# COPY class_names.txt .
+
+# Expose the port that the web server will listen on.
+# Azure Container Apps will route traffic to this port.
+EXPOSE 8080
+
+# The CMD instruction defines the command to run when the container starts.
+# We use Gunicorn to serve our Flask app, which will be defined in the scoring script.
+# The `conda run` command ensures the script is executed within the correct Conda environment.
+CMD ["conda", "run", "-n", "yolo-onnx-cpu-env", "gunicorn", "--bind", "0.0.0.0:8080", "scoring_Yolo_Model_Gunicorn:app"]

environment.yml

@@ -0,0 +1,24 @@
+channels:
+  - defaults
+  - conda-forge
+  - pytorch
+dependencies:
+  - python=3.10
+  - pip
+  - numpy=2.2.6
+  - opencv=4.12.0
+  - 'pytorch::pytorch=2.2.2'
+  - 'pytorch::torchvision=0.17.2'
+  - pip:
+      - azureml-defaults==1.54.0
+      - onnxruntime==1.22.1
+      - Pillow==11.3.0
+      - ultralytics==8.3.166
+      - coloredlogs==15.0.1
+      - flatbuffers==25.2.10
+      - humanfriendly==10.0
+      - mpmath==1.3.0
+      - packaging==24.0
+      - protobuf==6.31.1
+      - sympy==1.14.0
+name: yolo-onnx-cpu-env

scoring_Yolo_Model_Gunicorn.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Flask/Gunicorn wrapper for YOLO ONNX scoring script
+This file wraps the existing scoring_Yolo_Model.py for containerized deployment
+"""
+
+import os
+import sys
+import json
+import logging
+from flask import Flask, request, jsonify
+import traceback
+
+# Import your existing scoring script
+try:
+    from scoring_Yolo_Model import init as model_init, run as model_run
+except ImportError as e:
+    print(f"Error importing scoring_Yolo_Model: {e}")
+    sys.exit(1)
+
+# Configure logging for container environment
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Create Flask app
+app = Flask(__name__)
+
+# Global variable to track initialization
+model_initialized = False
+
+def initialize_model():
+    """Initialize the ONNX model on startup"""
+    global model_initialized
+    
+    try:
+        logger.info("🔄 Initializing YOLO ONNX model...")
+        model_init()
+        model_initialized = True
+        logger.info("✅ Model initialized successfully")
+        return True
+    except Exception as e:
+        logger.error(f"❌ Failed to initialize model: {e}")
+        logger.error(traceback.format_exc())
+        return False
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint for container orchestration"""
+    return jsonify({
+        'status': 'healthy' if model_initialized else 'unhealthy',
+        'model_initialized': model_initialized,
+        'service': 'yolo-onnx-scoring'
+    }), 200 if model_initialized else 503
+
+@app.route('/ready', methods=['GET'])
+def readiness_check():
+    """Readiness check endpoint"""
+    return jsonify({
+        'status': 'ready' if model_initialized else 'not_ready',
+        'model_initialized': model_initialized
+    }), 200 if model_initialized else 503
+
+@app.route('/score', methods=['POST'])
+def score():
+    """Main scoring endpoint that calls your existing scoring script"""
+    if not model_initialized:
+        return jsonify({
+            'error': 'Model not initialized',
+            'status': 'error'
+        }), 503
+    
+    try:
+        # Get raw JSON data from request
+        raw_data = request.get_data(as_text=True)
+        
+        if not raw_data:
+            return jsonify({
+                'error': 'No data provided',
+                'status': 'error'
+            }), 400
+        
+        # Log request info (without logging sensitive data)
+        logger.info(f"📥 Received scoring request")
+        
+        # Call your existing scoring function
+        result = model_run(raw_data)
+        
+        # Log response info
+        if isinstance(result, dict) and 'num_detections' in result:
+            logger.info(f"📤 Returning {result.get('num_detections', 0)} detections")
+        
+        return jsonify(result), 200
+        
+    except json.JSONDecodeError as e:
+        error_msg = f"Invalid JSON format: {e}"
+        logger.error(f"❌ {error_msg}")
+        return jsonify({
+            'error': error_msg,
+            'status': 'error'
+        }), 400
+        
+    except Exception as e:
+        error_msg = f"Scoring error: {str(e)}"
+        logger.error(f"❌ {error_msg}")
+        logger.error(traceback.format_exc())
+        return jsonify({
+            'error': error_msg,
+            'status': 'error'
+        }), 500
+
+@app.route('/info', methods=['GET'])
+def model_info():
+    """Get model information"""
+    return jsonify({
+        'model_type': 'YOLO ONNX',
+        'classes': ['Wall', 'Detail', 'Wall2'],
+        'input_size': [640, 640],
+        'confidence_threshold': 0.055,
+        'iou_threshold': 0.45,
+        'initialized': model_initialized
+    })
+
+@app.errorhandler(404)
+def not_found(error):
+    """Handle 404 errors"""
+    return jsonify({
+        'error': 'Endpoint not found',
+        'available_endpoints': ['/health', '/ready', '/score', '/info'],
+        'status': 'error'
+    }), 404
+
+@app.errorhandler(500)
+def internal_error(error):
+    """Handle 500 errors"""
+    logger.error(f"Internal server error: {error}")
+    return jsonify({
+        'error': 'Internal server error',
+        'status': 'error'
+    }), 500
+
+# Initialize model when the module is imported
+@app.before_first_request
+def startup():
+    """Initialize model before handling first request"""
+    if not model_initialized:
+        success = initialize_model()
+        if not success:
+            logger.error("❌ Failed to initialize model on startup")
+
+# For Gunicorn compatibility
+def create_app():
+    """Application factory for Gunicorn"""
+    # Initialize model if not already done
+    if not model_initialized:
+        success = initialize_model()
+        if not success:
+            raise RuntimeError("Failed to initialize YOLO model")
+    
+    return app
+
+# Entry point for development/testing
+if __name__ == '__main__':
+    # Initialize model
+    success = initialize_model()
+    if not success:
+        print("❌ Failed to initialize model. Exiting.")
+        sys.exit(1)
+    
+    # Run development server
+    print("🚀 Starting development server...")
+    app.run(
+        host='0.0.0.0',
+        port=int(os.environ.get('PORT', 8080)),
+        debug=False,
+        threaded=True
+    )
+else:
+    # For Gunicorn deployment
+    # Initialize model when imported by Gunicorn
+    if not model_initialized:
+        initialize_model()