{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Интеграция CoreML RusTorch - Rust Kernel\n",
"\n",
"Этот блокнот демонстрирует, как использовать CoreML с RusTorch.\n",
"Выполняется на ядре Rust."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Проверка необходимых зависимостей и функций"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"// Базовое использование RusTorch\n",
"extern crate rustorch;\n",
"\n",
"use rustorch::tensor::Tensor;\n",
"use rustorch::gpu::DeviceType;\n",
"\n",
"println!(\"Версия RusTorch: {}\", env!(\"CARGO_PKG_VERSION\"));\n",
"println!(\"Версия Rust: {}\", env!(\"RUSTC_VERSION\"));"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Проверка доступности CoreML\n",
"\n",
"Проверить, доступен ли CoreML в текущей системе."
]
},
{
"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 доступен: {}\", coreml_available);\n",
" \n",
" if coreml_available {\n",
" println!(\"🎉 CoreML доступен!\");\n",
" println!(\"Платформа: macOS\");\n",
" \n",
" // Показать информацию об устройстве\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!(\"Статистика кэша: {:?}\", stats);\n",
" } else {\n",
" println!(\"⚠️ CoreML недоступен\");\n",
" println!(\"Пожалуйста, используйте CPU или другие GPU бэкенды\");\n",
" }\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"❌ Функции CoreML не включены\");\n",
" println!(\"Пожалуйста, соберите с --features coreml\");\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Базовые операции с тензорами"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"// Создать базовые тензоры\n",
"let a = Tensor::zeros(&[2, 3]);\n",
"let b = Tensor::ones(&[3, 2]);\n",
"\n",
"println!(\"Форма тензора A: {:?}\", a.shape());\n",
"println!(\"Форма тензора B: {:?}\", b.shape());\n",
"\n",
"// Базовое умножение матриц\n",
"let result = a.matmul(&b);\n",
"println!(\"Форма результата: {:?}\", result.shape());\n",
"println!(\"Базовые операции с тензорами завершены\");"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Операции с устройством 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",
" // Попытаться создать устройство CoreML\n",
" match CoreMLDevice::new(0) {\n",
" Ok(device) => {\n",
" println!(\"🖥️ Устройство CoreML успешно создано\");\n",
" println!(\"ID устройства: {}\", device.id());\n",
" println!(\"Доступно: {}\", device.is_available());\n",
" println!(\"Лимит памяти: {} МБ\", device.memory_limit() / (1024 * 1024));\n",
" \n",
" // Создать конфигурацию бэкенда\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!(\"⚙️ Конфигурация бэкенда: {:?}\", config);\n",
" \n",
" // Создать бэкенд CoreML\n",
" match CoreMLBackend::new(device, config) {\n",
" Ok(backend) => {\n",
" println!(\"🚀 Бэкенд CoreML инициализирован\");\n",
" \n",
" // Получить статистику\n",
" let stats = backend.get_statistics();\n",
" println!(\"📊 Статистика бэкенда:\");\n",
" println!(\" Всего операций: {}\", stats.total_operations);\n",
" println!(\" Попадания в кэш: {}\", stats.cache_hits);\n",
" println!(\" Промахи кэша: {}\", stats.cache_misses);\n",
" println!(\" Операции отката: {}\", stats.fallback_operations);\n",
" \n",
" // Создать тензоры на 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!(\"📐 Тензоры созданы на устройстве CoreML\");\n",
" \n",
" // Операция умножения матриц\n",
" let start = std::time::Instant::now();\n",
" let result = tensor_a.matmul(&tensor_b);\n",
" let duration = start.elapsed();\n",
" \n",
" println!(\"✅ Умножение матриц завершено\");\n",
" println!(\"⏱️ Время выполнения: {:?}\", duration);\n",
" println!(\"🎯 Форма результата: {:?}\", result.shape());\n",
" \n",
" // Очистить кэш\n",
" backend.cleanup_cache();\n",
" println!(\"🧹 Кэш очищен\");\n",
" }\n",
" Err(e) => println!(\"❌ Ошибка создания бэкенда CoreML: {:?}\", e),\n",
" }\n",
" }\n",
" Err(e) => {\n",
" println!(\"❌ Ошибка создания устройства CoreML: {:?}\", e);\n",
" println!(\"CoreML может быть недоступен в этой системе\");\n",
" }\n",
" }\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"⚠️ Пропускаем операции CoreML - функции не включены\");\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Сравнение производительности"
]
},
{
"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!(\"🏁 Бенчмаркинг операций:\");\n",
" println!(\"Размер\\t\\tCPU (мс)\\tПредпочтительное устройство\");\n",
" println!(\"-\" * 55);\n",
" \n",
" for (rows, cols) in sizes {\n",
" // Создать тензоры на CPU\n",
" let a = Tensor::randn(&[rows, cols]);\n",
" let b = Tensor::randn(&[cols, rows]);\n",
" \n",
" // Измерить время CPU\n",
" let start = Instant::now();\n",
" let _result = a.matmul(&b);\n",
" let cpu_duration = start.elapsed();\n",
" \n",
" // Определить предпочтительное устройство\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📝 Примечание: Выбор устройства основан на размере тензора и доступности\");"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Умный выбор устройства"
]
},
{
"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!(\"🎯 Демонстрация умного выбора устройства:\");\n",
" \n",
" let operations = vec![\n",
" (\"Маленькое умножение\", vec![16, 16], \"CPU\"),\n",
" (\"2D свертка\", vec![32, 3, 224, 224], \"CoreML\"),\n",
" (\"Преобразование матрицы\", vec![128, 128], \"Metal GPU\"),\n",
" (\"Большая партийная операция\", vec![512, 512], \"CoreML\"),\n",
" (\"Векторное вычисление\", vec![1000], \"CPU\"),\n",
" ];\n",
" \n",
" for (name, shape, preferred) in operations {\n",
" println!(\" {:<25} {:?} -> {}\", name, shape, preferred);\n",
" \n",
" // Симулировать выбор на основе правил\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!(\" -> Выбранное устройство: {:?}\", selected_device);\n",
" }\n",
" \n",
" println!(\"\\n📝 Логика выбора:\");\n",
" println!(\" • < 1K элементов: CPU (минимальные накладные расходы)\");\n",
" println!(\" • 1K-50K элементов: Metal GPU (сбалансированный)\");\n",
" println!(\" • > 50K элементов: CoreML (оптимизированный) или Metal GPU (откат)\");\n",
" }\n",
" \n",
" demonstrate_device_selection();\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"⚠️ Демонстрация выбора устройства пропущена - функции CoreML недоступны\");\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Продвинутый пример: слой нейронной сети"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fn simulate_neural_layer() {\n",
" println!(\"🧠 Симуляция слоя нейронной сети:\");\n",
" \n",
" // Конфигурация слоя\n",
" let batch_size = 32;\n",
" let input_dim = 784; // 28x28 MNIST\n",
" let hidden_dim = 256;\n",
" let output_dim = 10; // 10 классов\n",
" \n",
" println!(\"📊 Конфигурация:\");\n",
" println!(\" Размер партии: {}\", batch_size);\n",
" println!(\" Входная размерность: {}\", input_dim);\n",
" println!(\" Скрытая размерность: {}\", hidden_dim);\n",
" println!(\" Выходная размерность: {}\", output_dim);\n",
" \n",
" // Создать тензоры\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🔄 Прямой проход:\");\n",
" \n",
" // Симулированный прямой проход\n",
" let start = Instant::now();\n",
" \n",
" // Слой 1: вход -> скрытый\n",
" let hidden = input.matmul(&weight1);\n",
" println!(\" ✅ Вход -> Скрытый: {:?}\", hidden.shape());\n",
" \n",
" // Функция активации ReLU (симулированная)\n",
" let activated = hidden.relu();\n",
" println!(\" ✅ Активация ReLU применена\");\n",
" \n",
" // Слой 2: скрытый -> выход\n",
" let output = activated.matmul(&weight2);\n",
" println!(\" ✅ Скрытый -> Выход: {:?}\", output.shape());\n",
" \n",
" let total_time = start.elapsed();\n",
" \n",
" println!(\"\\n⏱️ Общее время прямого прохода: {:?}\", total_time);\n",
" println!(\"🚀 Расчетная производительность: {:.0} образцов/секунду\", \n",
" (batch_size as f64) / total_time.as_secs_f64());\n",
" \n",
" println!(\"\\n📝 В реальной реализации:\");\n",
" println!(\" • Большие матрицы использовали бы CoreML\");\n",
" println!(\" • Активации использовали бы Metal GPU\");\n",
" println!(\" • Маленькие операции остались бы на CPU\");\n",
"}\n",
"\n",
"simulate_neural_layer();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Обработка ошибок и откат"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fn demonstrate_fallback_behavior() {\n",
" println!(\"🔄 Демонстрация поведения отката:\");\n",
" \n",
" // Симулировать операцию, которая может не сработать на CoreML\n",
" let complex_tensor = Tensor::randn(&[100, 100]);\n",
" \n",
" println!(\"🎯 Попытка операции CoreML...\");\n",
" \n",
" // В реальной реализации это было бы:\n",
" // match tensor.to_coreml() {\n",
" // Ok(coreml_tensor) => { /* использовать CoreML */ },\n",
" // Err(_) => { /* откат к Metal/CPU */ }\n",
" // }\n",
" \n",
" let use_coreml = false; // Симулировать сбой CoreML\n",
" \n",
" if use_coreml {\n",
" println!(\"✅ Операция CoreML успешна\");\n",
" } else {\n",
" println!(\"⚠️ CoreML недоступен, используем откат\");\n",
" \n",
" // Откат к Metal GPU\n",
" let start = Instant::now();\n",
" let result = complex_tensor.matmul(&complex_tensor);\n",
" let fallback_time = start.elapsed();\n",
" \n",
" println!(\"✅ Операция отката завершена\");\n",
" println!(\"⏱️ Время отката: {:?}\", fallback_time);\n",
" println!(\"📐 Форма результата: {:?}\", result.shape());\n",
" }\n",
" \n",
" println!(\"\\n📝 Стратегия отката:\");\n",
" println!(\" 1. Попробовать CoreML (лучшая производительность)\");\n",
" println!(\" 2. Откат к Metal GPU (хорошая совместимость)\");\n",
" println!(\" 3. Финальный откат к CPU (максимальная совместимость)\");\n",
"}\n",
"\n",
"demonstrate_fallback_behavior();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Резюме и следующие шаги"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"println!(\"📋 Резюме интеграции CoreML RusTorch (Rust Kernel):\");\n",
"println!();\n",
"println!(\"✅ Продемонстрированные функции:\");\n",
"println!(\" • Проверка доступности CoreML\");\n",
"println!(\" • Создание и управление устройствами\");\n",
"println!(\" • Конфигурация бэкенда\");\n",
"println!(\" • Базовые операции с тензорами\");\n",
"println!(\" • Бенчмаркинг производительности\");\n",
"println!(\" • Умный выбор устройства\");\n",
"println!(\" • Поведение отката\");\n",
"println!();\n",
"println!(\"🚧 Область разработки:\");\n",
"println!(\" • Полная реализация операций CoreML\");\n",
"println!(\" • Оптимизация передачи памяти\");\n",
"println!(\" • Расширенная поддержка типов тензоров\");\n",
"println!(\" • Детальное профилирование производительности\");\n",
"println!(\" • Интеграция с ML пайплайнами\");\n",
"println!();\n",
"println!(\"🎯 Рекомендуемые следующие шаги:\");\n",
"println!(\" 1. Тестировать с предобученными моделями CoreML\");\n",
"println!(\" 2. Сравнительный бенчмарк с другими бэкендами\");\n",
"println!(\" 3. Оптимизировать для конкретных случаев использования\");\n",
"println!(\" 4. Развернуть в производственных приложениях\");\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!(\"🎉 Все функции CoreML доступны для тестирования!\");\n",
" } else {\n",
" println!(\"⚠️ CoreML включен, но недоступен в этой системе\");\n",
" }\n",
"}\n",
"\n",
"#[cfg(not(any(feature = \"coreml\", feature = \"coreml-hybrid\", feature = \"coreml-fallback\")))]\n",
"{\n",
" println!(\"⚠️ Соберите с функциями CoreML для полной функциональности\");\n",
"}\n",
"\n",
"println!(\"\\n🚀 Готов к продвинутой разработке CoreML с 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
}