import torch
import torchvision.models as models

# Seu modelo treinado (exemplo: ResNet)
modelo = models.resnet18(pretrained=True)
modelo.eval()

# Criando entrada exemplo
exemplo = torch.randn(1, 3, 224, 224)

# Exportar para ONNX
torch.onnx.export(
    modelo,                     # modelo treinado
    exemplo,                    # entrada exemplo
    "modelo_drone.onnx",        # nome do arquivo
    export_params=True,         # exportar parâmetros treinados
    opset_version=11,           # versão do ONNX
    input_names=['input'],      # nome da entrada
    output_names=['output'],    # nome da saída
    dynamic_axes={
        'input': {0: 'batch_size'},
        'output': {0: 'batch_size'}
    }
)

print("✅ Modelo convertido para ONNX!")

import cv2
import numpy as np
import onnxruntime as ort
import time

# Carregar modelo otimizado para Jetson
sess = ort.InferenceSession("modelo_drone.onnx")

# Capturar vídeo da câmera do drone
cap = cv2.VideoCapture(0)  # ou feed do drone

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # Pré-processamento
    input_frame = cv2.resize(frame, (224, 224))
    input_frame = input_frame.transpose(2,0,1)  # HWC -> CHW
    input_frame = input_frame.astype(np.float32) / 255.0
    input_frame = np.expand_dims(input_frame, axis=0)
    
    # Inferência
    start = time.time()
    outputs = sess.run(['output'], {'input': input_frame})
    fps = 1 / (time.time() - start)
    
    # Detecção (exemplo: praga ou não)
    if outputs[0][0][0] > 0.5:
        cv2.putText(frame, "⚠️ PRAGA DETECTADA!", 
                   (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
                   1, (0, 0, 255), 2)
    
    cv2.putText(frame, f"FPS: {fps:.1f}", (10, 60),
               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,255,255), 2)
    
    # Enviar alerta se necessário
    if outputs[0][0][0] > 0.8:
        print("🚨 ALERTA CRÍTICO: Enviando coordenadas...")
        # Aqui você enviaria GPS do drone
        
    cv2.imshow('Drone Monitor', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import tensorflow as tf

# Carregar modelo Keras (treinado)
modelo = tf.keras.models.load_model("modelo_agro.h5")

# Converter para TensorFlow Lite
converter = tf.lite.TFLiteConverter.from_keras_model(modelo)

# Otimizações para mobile
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]

tflite_model = converter.convert()

# Salvar
with open('modelo_mobile.tflite', 'wb') as f:
    f.write(tflite_model)

print("✅ Modelo pronto para Android/iOS!")

// Android - TensorFlow Lite
class ClassificadorAgro {
    private val tflite: Interpreter
    
    init {
        // Carregar modelo do assets
        val model = loadModelFile(context, "modelo_mobile.tflite")
        tflite = Interpreter(model)
    }
    
    fun classificarSolo(umidade: Float, ph: Float, nitrogenio: Float): String {
        val inputs = arrayOf(floatArrayOf(umidade, ph, nitrogenio))
        val outputs = Array(1) { FloatArray(3) }
        
        tflite.run(inputs, outputs)
        
        return when (outputs[0].indices.maxByOrNull { outputs[0][it] }) {
            0 -> "🌱 Solo ideal para plantio"
            1 -> "⚠️ Necessita correção"
            2 -> "🚫 Solo inadequado"
            else -> "🤖 Analisando..."
        }
    }
}

from fastapi import FastAPI, UploadFile
import uvicorn
import numpy as np
import onnxruntime as ort
from PIL import Image
import io

app = FastAPI(title="API Agro 5.0")

# Carregar modelo ONNX
sess = ort.InferenceSession("modelo_drone.onnx")

@app.post("/predict")
async def predict(file: UploadFile):
    # Ler imagem
    image = Image.open(io.BytesIO(await file.read()))
    image = image.resize((224, 224))
    
    # Pré-processar
    input_array = np.array(image).astype(np.float32) / 255.0
    input_array = input_array.transpose(2,0,1)
    input_array = np.expand_dims(input_array, axis=0)
    
    # Inferência
    outputs = sess.run(['output'], {'input': input_array})
    
    return {
        "probabilidade": float(outputs[0][0][0]),
        "classificacao": "PRAGA" if outputs[0][0][0] > 0.5 else "SAUDÁVEL",
        "status": "success"
    }

@app.get("/health")
async def health():
    return {"status": "online", "modelo": "Agro 5.0 v1"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

import requests

# Enviar imagem para API
url = "http://192.168.0.100:8000/predict"
files = {"file": ("foto.jpg", open("lavoura.jpg", "rb"), "image/jpeg")}

response = requests.post(url, files=files)
resultado = response.json()

print(f"🌾 Resultado: {resultado['classificacao']}")
print(f"📊 Confiança: {resultado['probabilidade']*100:.1f}%")

# Se for praga, acionar alerta
if resultado['classificacao'] == "PRAGA":
    requests.post("http://api.drone/alert", 
                 json={"coordenadas": "-25.432, -54.588"})