{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Integración CoreML de RusTorch - Kernel Rust\n",
"\n",
"Este notebook demuestra cómo usar CoreML con RusTorch.\n",
"Se ejecuta en el kernel Rust."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Verificar Dependencias y Características Requeridas"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"// Uso básico de RusTorch\n",
"extern crate rustorch;\n",
"\n",
"use rustorch::tensor::Tensor;\n",
"use rustorch::gpu::DeviceType;\n",
"\n",
"println!(\"Versión de RusTorch: {}\", env!(\"CARGO_PKG_VERSION\"));\n",
"println!(\"Versión de Rust: {}\", env!(\"RUSTC_VERSION\"));"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Verificar Disponibilidad de CoreML\n",
"\n",
"Verificar si CoreML está disponible en el sistema actual."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#[cfg(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\"))]\n",
"{\n",
" use rustorch::backends::DeviceManager;\n",
" \n",
" let coreml_available = DeviceManager::is_coreml_available();\n",
" println!(\"CoreML disponible: {}\", coreml_available);\n",
" \n",
" if coreml_available {\n",
" println!(\"🎉 ¡CoreML está disponible!\");\n",
" println!(\"Plataforma: macOS\");\n",
" \n",
" // Mostrar información del dispositivo\n",
" use rustorch::gpu::coreml::device_cache::DeviceCache;\n",
" let cache = DeviceCache::global();\n",
" cache.warmup();\n",
" \n",
" let stats = cache.get_stats();\n",
" println!(\"Estadísticas de caché: {:?}\", stats);\n",
" } else {\n",
" println!(\"⚠️ CoreML no está disponible\");\n",
" println!(\"Por favor use CPU u otros backends GPU\");\n",
" }\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"❌ Las características CoreML no están habilitadas\");\n",
" println!(\"Por favor construya con --features coreml\");\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Operaciones Básicas de Tensores"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"// Crear tensores básicos\n",
"let a = Tensor::zeros(&[2, 3]);\n",
"let b = Tensor::ones(&[3, 2]);\n",
"\n",
"println!(\"Forma del tensor A: {:?}\", a.shape());\n",
"println!(\"Forma del tensor B: {:?}\", b.shape());\n",
"\n",
"// Multiplicación de matrices básica\n",
"let result = a.matmul(&b);\n",
"println!(\"Forma del resultado: {:?}\", result.shape());\n",
"println!(\"Operaciones básicas de tensores completadas\");"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Operaciones con Dispositivo CoreML"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#[cfg(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\"))]\n",
"{\n",
" use rustorch::gpu::coreml::{CoreMLDevice, CoreMLBackend};\n",
" use rustorch::backends::BackendConfig;\n",
" \n",
" // Intentar crear dispositivo CoreML\n",
" match CoreMLDevice::new(0) {\n",
" Ok(device) => {\n",
" println!(\"🖥️ Dispositivo CoreML creado exitosamente\");\n",
" println!(\"ID del dispositivo: {}\", device.id());\n",
" println!(\"Disponible: {}\", device.is_available());\n",
" println!(\"Límite de memoria: {} MB\", device.memory_limit() / (1024 * 1024));\n",
" \n",
" // Crear configuración del backend\n",
" let config = BackendConfig::new()\n",
" .with_caching(true)\n",
" .with_max_cache_size(200)\n",
" .with_profiling(true)\n",
" .with_auto_fallback(true);\n",
" \n",
" println!(\"⚙️ Configuración del backend: {:?}\", config);\n",
" \n",
" // Crear backend CoreML\n",
" match CoreMLBackend::new(device, config) {\n",
" Ok(backend) => {\n",
" println!(\"🚀 Backend CoreML inicializado\");\n",
" \n",
" // Obtener estadísticas\n",
" let stats = backend.get_statistics();\n",
" println!(\"📊 Estadísticas del backend:\");\n",
" println!(\" Operaciones totales: {}\", stats.total_operations);\n",
" println!(\" Aciertos de caché: {}\", stats.cache_hits);\n",
" println!(\" Fallos de caché: {}\", stats.cache_misses);\n",
" println!(\" Operaciones de respaldo: {}\", stats.fallback_operations);\n",
" \n",
" // Crear tensores en CoreML\n",
" let tensor_a = Tensor::randn(&[64, 64]).to_device(&backend);\n",
" let tensor_b = Tensor::randn(&[64, 64]).to_device(&backend);\n",
" \n",
" println!(\"📐 Tensores creados en dispositivo CoreML\");\n",
" \n",
" // Operación de multiplicación de matrices\n",
" let start = std::time::Instant::now();\n",
" let result = tensor_a.matmul(&tensor_b);\n",
" let duration = start.elapsed();\n",
" \n",
" println!(\"✅ Multiplicación de matrices completada\");\n",
" println!(\"⏱️ Tiempo de ejecución: {:?}\", duration);\n",
" println!(\"🎯 Forma del resultado: {:?}\", result.shape());\n",
" \n",
" // Limpiar caché\n",
" backend.cleanup_cache();\n",
" println!(\"🧹 Caché limpiado\");\n",
" }\n",
" Err(e) => println!(\"❌ Error al crear backend CoreML: {:?}\", e),\n",
" }\n",
" }\n",
" Err(e) => {\n",
" println!(\"❌ Error al crear dispositivo CoreML: {:?}\", e);\n",
" println!(\"Puede que CoreML no esté disponible en este sistema\");\n",
" }\n",
" }\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"⚠️ Omitiendo operaciones CoreML - características no habilitadas\");\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Comparación de Rendimiento"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"use std::time::Instant;\n",
"\n",
"fn benchmark_operations() {\n",
" let sizes = vec![(64, 64), (128, 128), (256, 256), (512, 512)];\n",
" \n",
" println!(\"🏁 Evaluación comparativa de operaciones:\");\n",
" println!(\"Tamaño\\t\\tCPU (ms)\\tDispositivo Preferido\");\n",
" println!(\"-\" * 45);\n",
" \n",
" for (rows, cols) in sizes {\n",
" // Crear tensores en CPU\n",
" let a = Tensor::randn(&[rows, cols]);\n",
" let b = Tensor::randn(&[cols, rows]);\n",
" \n",
" // Medir tiempo CPU\n",
" let start = Instant::now();\n",
" let _result = a.matmul(&b);\n",
" let cpu_duration = start.elapsed();\n",
" \n",
" // Determinar dispositivo preferido\n",
" let preferred_device = if rows * cols < 1000 {\n",
" \"CPU\"\n",
" } else if rows * cols < 10000 {\n",
" \"Metal GPU\"\n",
" } else {\n",
" \"CoreML\"\n",
" };\n",
" \n",
" println!(\"{}x{}\\t\\t{:.2}\\t\\t{}\", \n",
" rows, cols, \n",
" cpu_duration.as_millis() as f64, \n",
" preferred_device);\n",
" }\n",
"}\n",
"\n",
"benchmark_operations();\n",
"println!(\"\\n📝 Nota: La selección de dispositivo se basa en tamaño de tensor y disponibilidad\");"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Selección Inteligente de Dispositivo"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#[cfg(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\"))]\n",
"{\n",
" use rustorch::backends::{DeviceManager, DeviceSelector};\n",
" \n",
" fn demonstrate_device_selection() {\n",
" println!(\"🎯 Demostración de selección inteligente de dispositivo:\");\n",
" \n",
" let operations = vec![\n",
" (\"Multiplicación pequeña\", vec![16, 16], \"CPU\"),\n",
" (\"Convolución 2D\", vec![32, 3, 224, 224], \"CoreML\"),\n",
" (\"Transformación de matriz\", vec![128, 128], \"Metal GPU\"),\n",
" (\"Operación de lote grande\", vec![512, 512], \"CoreML\"),\n",
" (\"Cálculo vectorial\", vec![1000], \"CPU\"),\n",
" ];\n",
" \n",
" for (name, shape, preferred) in operations {\n",
" println!(\" {:<25} {:?} -> {}\", name, shape, preferred);\n",
" \n",
" // Simular selección basada en reglas\n",
" let tensor_size: usize = shape.iter().product();\n",
" let selected_device = match tensor_size {\n",
" size if size < 1000 => DeviceType::Cpu,\n",
" size if size < 50000 => DeviceType::MetalGpu,\n",
" _ => {\n",
" if DeviceManager::is_coreml_available() {\n",
" DeviceType::CoreML\n",
" } else {\n",
" DeviceType::MetalGpu\n",
" }\n",
" }\n",
" };\n",
" \n",
" println!(\" -> Dispositivo seleccionado: {:?}\", selected_device);\n",
" }\n",
" \n",
" println!(\"\\n📝 Lógica de selección:\");\n",
" println!(\" • < 1K elementos: CPU (sobrecarga mínima)\");\n",
" println!(\" • 1K-50K elementos: Metal GPU (equilibrado)\");\n",
" println!(\" • > 50K elementos: CoreML (optimizado) o Metal GPU (respaldo)\");\n",
" }\n",
" \n",
" demonstrate_device_selection();\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"⚠️ Demostración de selección de dispositivo omitida - características CoreML no disponibles\");\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ejemplo Avanzado: Capa de Red Neuronal"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fn simulate_neural_layer() {\n",
" println!(\"🧠 Simulación de capa de red neuronal:\");\n",
" \n",
" // Configuración de la capa\n",
" let batch_size = 32;\n",
" let input_dim = 784; // 28x28 MNIST\n",
" let hidden_dim = 256;\n",
" let output_dim = 10; // 10 clases\n",
" \n",
" println!(\"📊 Configuración:\");\n",
" println!(\" Tamaño del lote: {}\", batch_size);\n",
" println!(\" Dimensión de entrada: {}\", input_dim);\n",
" println!(\" Dimensión oculta: {}\", hidden_dim);\n",
" println!(\" Dimensión de salida: {}\", output_dim);\n",
" \n",
" // Crear tensores\n",
" let input = Tensor::randn(&[batch_size, input_dim]);\n",
" let weight1 = Tensor::randn(&[input_dim, hidden_dim]);\n",
" let weight2 = Tensor::randn(&[hidden_dim, output_dim]);\n",
" \n",
" println!(\"\\n🔄 Pase hacia adelante:\");\n",
" \n",
" // Pase hacia adelante simulado\n",
" let start = Instant::now();\n",
" \n",
" // Capa 1: entrada -> oculta\n",
" let hidden = input.matmul(&weight1);\n",
" println!(\" ✅ Entrada -> Oculta: {:?}\", hidden.shape());\n",
" \n",
" // Función de activación ReLU (simulada)\n",
" let activated = hidden.relu();\n",
" println!(\" ✅ Activación ReLU aplicada\");\n",
" \n",
" // Capa 2: oculta -> salida\n",
" let output = activated.matmul(&weight2);\n",
" println!(\" ✅ Oculta -> Salida: {:?}\", output.shape());\n",
" \n",
" let total_time = start.elapsed();\n",
" \n",
" println!(\"\\n⏱️ Tiempo total del pase hacia adelante: {:?}\", total_time);\n",
" println!(\"🚀 Rendimiento estimado: {:.0} muestras/segundo\", \n",
" (batch_size as f64) / total_time.as_secs_f64());\n",
" \n",
" println!(\"\\n📝 En una implementación real:\");\n",
" println!(\" • Matrices grandes usarían CoreML\");\n",
" println!(\" • Activaciones usarían Metal GPU\");\n",
" println!(\" • Operaciones pequeñas permanecerían en CPU\");\n",
"}\n",
"\n",
"simulate_neural_layer();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Manejo de Errores y Respaldo"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fn demonstrate_fallback_behavior() {\n",
" println!(\"🔄 Demostración de comportamiento de respaldo:\");\n",
" \n",
" // Simular operación que podría fallar en CoreML\n",
" let complex_tensor = Tensor::randn(&[100, 100]);\n",
" \n",
" println!(\"🎯 Intentando operación CoreML...\");\n",
" \n",
" // En implementación real, esto sería:\n",
" // match tensor.to_coreml() {\n",
" // Ok(coreml_tensor) => { /* usar CoreML */ },\n",
" // Err(_) => { /* respaldo a Metal/CPU */ }\n",
" // }\n",
" \n",
" let use_coreml = false; // Simular fallo CoreML\n",
" \n",
" if use_coreml {\n",
" println!(\"✅ Operación CoreML exitosa\");\n",
" } else {\n",
" println!(\"⚠️ CoreML no disponible, usando respaldo\");\n",
" \n",
" // Respaldo a Metal GPU\n",
" let start = Instant::now();\n",
" let result = complex_tensor.matmul(&complex_tensor);\n",
" let fallback_time = start.elapsed();\n",
" \n",
" println!(\"✅ Operación de respaldo completada\");\n",
" println!(\"⏱️ Tiempo de respaldo: {:?}\", fallback_time);\n",
" println!(\"📐 Forma del resultado: {:?}\", result.shape());\n",
" }\n",
" \n",
" println!(\"\\n📝 Estrategia de respaldo:\");\n",
" println!(\" 1. Intentar CoreML (mejor rendimiento)\");\n",
" println!(\" 2. Respaldo a Metal GPU (buena compatibilidad)\");\n",
" println!(\" 3. Respaldo final a CPU (máxima compatibilidad)\");\n",
"}\n",
"\n",
"demonstrate_fallback_behavior();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Resumen y Próximos Pasos"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"println!(\"📋 Resumen de Integración CoreML de RusTorch (Rust Kernel):\");\n",
"println!();\n",
"println!(\"✅ Características demostradas:\");\n",
"println!(\" • Verificación de disponibilidad CoreML\");\n",
"println!(\" • Creación y gestión de dispositivos\");\n",
"println!(\" • Configuración del backend\");\n",
"println!(\" • Operaciones básicas de tensores\");\n",
"println!(\" • Evaluación comparativa de rendimiento\");\n",
"println!(\" • Selección inteligente de dispositivo\");\n",
"println!(\" • Comportamiento de respaldo\");\n",
"println!();\n",
"println!(\"🚧 Área de desarrollo:\");\n",
"println!(\" • Implementación completa de operaciones CoreML\");\n",
"println!(\" • Optimización de transferencia de memoria\");\n",
"println!(\" • Soporte ampliado para tipos de tensor\");\n",
"println!(\" • Perfilado detallado de rendimiento\");\n",
"println!(\" • Integración con pipelines de ML\");\n",
"println!();\n",
"println!(\"🎯 Próximos pasos recomendados:\");\n",
"println!(\" 1. Probar con modelos CoreML preentrenados\");\n",
"println!(\" 2. Evaluar comparativamente con otros backends\");\n",
"println!(\" 3. Optimizar para casos de uso específicos\");\n",
"println!(\" 4. Implementar en aplicaciones de producción\");\n",
"println!();\n",
"\n",
"#[cfg(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\"))]\n",
"{\n",
" if rustorch::backends::DeviceManager::is_coreml_available() {\n",
" println!(\"🎉 ¡Todas las características CoreML están disponibles para pruebas!\");\n",
" } else {\n",
" println!(\"⚠️ CoreML está habilitado pero no disponible en este sistema\");\n",
" }\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"⚠️ Construya con características CoreML para funcionalidad completa\");\n",
"}\n",
"\n",
"println!(\"\\n🚀 Listo para el desarrollo avanzado de CoreML con RusTorch!\");"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Rust",
"language": "rust",
"name": "rust"
},
"language_info": {
"codemirror_mode": "rust",
"file_extension": ".rs",
"mimetype": "text/rust",
"name": "Rust",
"pygments_lexer": "rust",
"version": ""
}
},
"nbformat": 4,
"nbformat_minor": 4
}