{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Integração CoreML do RusTorch - Kernel Rust\n",
"\n",
"Este notebook demonstra como usar CoreML com RusTorch.\n",
"Executa no kernel Rust."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Verificar Dependências e Recursos Necessários"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"// Uso básico do RusTorch\n",
"extern crate rustorch;\n",
"\n",
"use rustorch::tensor::Tensor;\n",
"use rustorch::gpu::DeviceType;\n",
"\n",
"println!(\"Versão do RusTorch: {}\", env!(\"CARGO_PKG_VERSION\"));\n",
"println!(\"Versão do Rust: {}\", env!(\"RUSTC_VERSION\"));"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Verificar Disponibilidade do CoreML\n",
"\n",
"Verificar se CoreML está disponível no sistema atual."
]
},
{
"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 disponível: {}\", coreml_available);\n",
" \n",
" if coreml_available {\n",
" println!(\"🎉 CoreML está disponível!\");\n",
" println!(\"Plataforma: macOS\");\n",
" \n",
" // Exibir informações do 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!(\"Estatísticas do cache: {:?}\", stats);\n",
" } else {\n",
" println!(\"⚠️ CoreML não está disponível\");\n",
" println!(\"Por favor, use CPU ou outros backends GPU\");\n",
" }\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"❌ Recursos CoreML não estão habilitados\");\n",
" println!(\"Por favor, compile com --features coreml\");\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Operações Básicas de Tensor"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"// Criar tensores básicos\n",
"let a = Tensor::zeros(&[2, 3]);\n",
"let b = Tensor::ones(&[3, 2]);\n",
"\n",
"println!(\"Forma do tensor A: {:?}\", a.shape());\n",
"println!(\"Forma do tensor B: {:?}\", b.shape());\n",
"\n",
"// Multiplicação básica de matrizes\n",
"let result = a.matmul(&b);\n",
"println!(\"Forma do resultado: {:?}\", result.shape());\n",
"println!(\"Operações básicas de tensor completadas\");"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Operações com 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",
" // Tentar criar dispositivo CoreML\n",
" match CoreMLDevice::new(0) {\n",
" Ok(device) => {\n",
" println!(\"🖥️ Dispositivo CoreML criado com sucesso\");\n",
" println!(\"ID do dispositivo: {}\", device.id());\n",
" println!(\"Disponível: {}\", device.is_available());\n",
" println!(\"Limite de memória: {} MB\", device.memory_limit() / (1024 * 1024));\n",
" \n",
" // Criar configuração do 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!(\"⚙️ Configuração do backend: {:?}\", config);\n",
" \n",
" // Criar backend CoreML\n",
" match CoreMLBackend::new(device, config) {\n",
" Ok(backend) => {\n",
" println!(\"🚀 Backend CoreML inicializado\");\n",
" \n",
" // Obter estatísticas\n",
" let stats = backend.get_statistics();\n",
" println!(\"📊 Estatísticas do backend:\");\n",
" println!(\" Operações totais: {}\", stats.total_operations);\n",
" println!(\" Acertos de cache: {}\", stats.cache_hits);\n",
" println!(\" Erros de cache: {}\", stats.cache_misses);\n",
" println!(\" Operações de fallback: {}\", stats.fallback_operations);\n",
" \n",
" // Criar tensores no 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 criados no dispositivo CoreML\");\n",
" \n",
" // Operação de multiplicação de matrizes\n",
" let start = std::time::Instant::now();\n",
" let result = tensor_a.matmul(&tensor_b);\n",
" let duration = start.elapsed();\n",
" \n",
" println!(\"✅ Multiplicação de matrizes completada\");\n",
" println!(\"⏱️ Tempo de execução: {:?}\", duration);\n",
" println!(\"🎯 Forma do resultado: {:?}\", result.shape());\n",
" \n",
" // Limpar cache\n",
" backend.cleanup_cache();\n",
" println!(\"🧹 Cache limpo\");\n",
" }\n",
" Err(e) => println!(\"❌ Erro ao criar backend CoreML: {:?}\", e),\n",
" }\n",
" }\n",
" Err(e) => {\n",
" println!(\"❌ Erro ao criar dispositivo CoreML: {:?}\", e);\n",
" println!(\"CoreML pode não estar disponível neste sistema\");\n",
" }\n",
" }\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"⚠️ Pulando operações CoreML - recursos não habilitados\");\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Comparação de Performance"
]
},
{
"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!(\"🏁 Benchmarking de operações:\");\n",
" println!(\"Tamanho\\t\\tCPU (ms)\\tDispositivo Preferido\");\n",
" println!(\"-\" * 48);\n",
" \n",
" for (rows, cols) in sizes {\n",
" // Criar tensores na CPU\n",
" let a = Tensor::randn(&[rows, cols]);\n",
" let b = Tensor::randn(&[cols, rows]);\n",
" \n",
" // Medir tempo da 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: A seleção de dispositivo é baseada no tamanho do tensor e disponibilidade\");"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Seleção 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!(\"🎯 Demonstração de seleção inteligente de dispositivo:\");\n",
" \n",
" let operations = vec![\n",
" (\"Multiplicação pequena\", vec![16, 16], \"CPU\"),\n",
" (\"Convolução 2D\", vec![32, 3, 224, 224], \"CoreML\"),\n",
" (\"Transformação de matriz\", vec![128, 128], \"Metal GPU\"),\n",
" (\"Operação de lote grande\", vec![512, 512], \"CoreML\"),\n",
" (\"Cálculo vetorial\", vec![1000], \"CPU\"),\n",
" ];\n",
" \n",
" for (name, shape, preferred) in operations {\n",
" println!(\" {:<25} {:?} -> {}\", name, shape, preferred);\n",
" \n",
" // Simular seleção baseada em regras\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 selecionado: {:?}\", selected_device);\n",
" }\n",
" \n",
" println!(\"\\n📝 Lógica de seleção:\");\n",
" println!(\" • < 1K elementos: CPU (overhead mínimo)\");\n",
" println!(\" • 1K-50K elementos: Metal GPU (balanceado)\");\n",
" println!(\" • > 50K elementos: CoreML (otimizado) ou Metal GPU (fallback)\");\n",
" }\n",
" \n",
" demonstrate_device_selection();\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"⚠️ Demonstração de seleção de dispositivo pulada - recursos CoreML não disponíveis\");\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exemplo Avançado: Camada de Rede Neural"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fn simulate_neural_layer() {\n",
" println!(\"🧠 Simulação de camada de rede neural:\");\n",
" \n",
" // Configuração da camada\n",
" let batch_size = 32;\n",
" let input_dim = 784; // 28x28 MNIST\n",
" let hidden_dim = 256;\n",
" let output_dim = 10; // 10 classes\n",
" \n",
" println!(\"📊 Configuração:\");\n",
" println!(\" Tamanho do lote: {}\", batch_size);\n",
" println!(\" Dimensão de entrada: {}\", input_dim);\n",
" println!(\" Dimensão oculta: {}\", hidden_dim);\n",
" println!(\" Dimensão de saída: {}\", output_dim);\n",
" \n",
" // Criar 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🔄 Forward pass:\");\n",
" \n",
" // Forward pass simulado\n",
" let start = Instant::now();\n",
" \n",
" // Camada 1: entrada -> oculta\n",
" let hidden = input.matmul(&weight1);\n",
" println!(\" ✅ Entrada -> Oculta: {:?}\", hidden.shape());\n",
" \n",
" // Função de ativação ReLU (simulada)\n",
" let activated = hidden.relu();\n",
" println!(\" ✅ Ativação ReLU aplicada\");\n",
" \n",
" // Camada 2: oculta -> saída\n",
" let output = activated.matmul(&weight2);\n",
" println!(\" ✅ Oculta -> Saída: {:?}\", output.shape());\n",
" \n",
" let total_time = start.elapsed();\n",
" \n",
" println!(\"\\n⏱️ Tempo total do forward pass: {:?}\", total_time);\n",
" println!(\"🚀 Performance estimada: {:.0} amostras/segundo\", \n",
" (batch_size as f64) / total_time.as_secs_f64());\n",
" \n",
" println!(\"\\n📝 Em uma implementação real:\");\n",
" println!(\" • Matrizes grandes usariam CoreML\");\n",
" println!(\" • Ativações usariam Metal GPU\");\n",
" println!(\" • Operações pequenas permaneceriam na CPU\");\n",
"}\n",
"\n",
"simulate_neural_layer();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tratamento de Erros e Fallback"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fn demonstrate_fallback_behavior() {\n",
" println!(\"🔄 Demonstração de comportamento de fallback:\");\n",
" \n",
" // Simular operação que pode falhar no CoreML\n",
" let complex_tensor = Tensor::randn(&[100, 100]);\n",
" \n",
" println!(\"🎯 Tentando operação CoreML...\");\n",
" \n",
" // Na implementação real, isso seria:\n",
" // match tensor.to_coreml() {\n",
" // Ok(coreml_tensor) => { /* usar CoreML */ },\n",
" // Err(_) => { /* fallback para Metal/CPU */ }\n",
" // }\n",
" \n",
" let use_coreml = false; // Simular falha do CoreML\n",
" \n",
" if use_coreml {\n",
" println!(\"✅ Operação CoreML bem-sucedida\");\n",
" } else {\n",
" println!(\"⚠️ CoreML não disponível, usando fallback\");\n",
" \n",
" // Fallback para Metal GPU\n",
" let start = Instant::now();\n",
" let result = complex_tensor.matmul(&complex_tensor);\n",
" let fallback_time = start.elapsed();\n",
" \n",
" println!(\"✅ Operação de fallback completada\");\n",
" println!(\"⏱️ Tempo de fallback: {:?}\", fallback_time);\n",
" println!(\"📐 Forma do resultado: {:?}\", result.shape());\n",
" }\n",
" \n",
" println!(\"\\n📝 Estratégia de fallback:\");\n",
" println!(\" 1. Tentar CoreML (melhor performance)\");\n",
" println!(\" 2. Fallback para Metal GPU (boa compatibilidade)\");\n",
" println!(\" 3. Fallback final para CPU (máxima compatibilidade)\");\n",
"}\n",
"\n",
"demonstrate_fallback_behavior();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Resumo e Próximos Passos"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"println!(\"📋 Resumo da Integração CoreML do RusTorch (Kernel Rust):\");\n",
"println!();\n",
"println!(\"✅ Recursos demonstrados:\");\n",
"println!(\" • Verificação de disponibilidade CoreML\");\n",
"println!(\" • Criação e gerenciamento de dispositivos\");\n",
"println!(\" • Configuração do backend\");\n",
"println!(\" • Operações básicas de tensor\");\n",
"println!(\" • Benchmarking de performance\");\n",
"println!(\" • Seleção inteligente de dispositivo\");\n",
"println!(\" • Comportamento de fallback\");\n",
"println!();\n",
"println!(\"🚧 Área de desenvolvimento:\");\n",
"println!(\" • Implementação completa de operações CoreML\");\n",
"println!(\" • Otimização de transferência de memória\");\n",
"println!(\" • Suporte estendido para tipos de tensor\");\n",
"println!(\" • Profiling detalhado de performance\");\n",
"println!(\" • Integração com pipelines ML\");\n",
"println!();\n",
"println!(\"🎯 Próximos passos recomendados:\");\n",
"println!(\" 1. Testar com modelos CoreML pré-treinados\");\n",
"println!(\" 2. Benchmark comparativo com outros backends\");\n",
"println!(\" 3. Otimizar para casos de uso específicos\");\n",
"println!(\" 4. Implantar em aplicações de produção\");\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!(\"🎉 Todos os recursos CoreML estão disponíveis para teste!\");\n",
" } else {\n",
" println!(\"⚠️ CoreML está habilitado mas não disponível neste sistema\");\n",
" }\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"⚠️ Compile com recursos CoreML para funcionalidade completa\");\n",
"}\n",
"\n",
"println!(\"\\n🚀 Pronto para desenvolvimento avançado CoreML com 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
}