{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Интеграция CoreML RusTorch - Python Bindings\n",
"\n",
"Этот блокнот демонстрирует, как использовать функциональность CoreML RusTorch через Python bindings."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Настройка и импорты"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Импорт Python bindings RusTorch\n",
"try:\n",
" import rustorch\n",
" print(f\"✅ Версия RusTorch: {rustorch.__version__}\")\n",
" print(f\"📝 Описание: {rustorch.__description__}\")\n",
" print(f\"👥 Автор: {rustorch.__author__}\")\n",
"except ImportError as e:\n",
" print(f\"❌ Не удалось импортировать RusTorch: {e}\")\n",
" print(\"Пожалуйста, соберите с помощью maturin develop\")\n",
" exit(1)\n",
"\n",
"import numpy as np\n",
"import platform\n",
"\n",
"print(f\"🖥️ Платформа: {platform.system()} {platform.release()}\")\n",
"print(f\"🐍 Версия Python: {platform.python_version()}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Проверка доступности CoreML"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Проверка функциональности CoreML\n",
"try:\n",
" # Проверить, доступен ли CoreML\n",
" coreml_available = rustorch.is_coreml_available()\n",
" print(f\"🍎 CoreML доступен: {coreml_available}\")\n",
" \n",
" if coreml_available:\n",
" print(\"🎉 CoreML доступен!\")\n",
" \n",
" # Получить информацию об устройстве\n",
" device_info = rustorch.get_coreml_device_info()\n",
" print(\"📱 Информация об устройстве CoreML:\")\n",
" print(device_info)\n",
" else:\n",
" print(\"⚠️ CoreML недоступен\")\n",
" if platform.system() != \"Darwin\":\n",
" print(\"CoreML доступен только на macOS\")\n",
" else:\n",
" print(\"Функции CoreML могут быть не включены\")\n",
" \n",
"except AttributeError:\n",
" print(\"❌ Функции CoreML не найдены\")\n",
" print(\"Возможно, не собрано с функциями CoreML\")\n",
" coreml_available = False\n",
"except Exception as e:\n",
" print(f\"❌ Ошибка при проверке CoreML: {e}\")\n",
" coreml_available = False"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Создание устройства CoreML и операции"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"if coreml_available:\n",
" try:\n",
" # Создать устройство CoreML\n",
" device = rustorch.CoreMLDevice(device_id=0)\n",
" print(f\"🖥️ Устройство CoreML создано: {device}\")\n",
" \n",
" # Получить информацию об устройстве\n",
" print(f\"🆔 ID устройства: {device.device_id()}\")\n",
" print(f\"✅ Доступно: {device.is_available()}\")\n",
" print(f\"💾 Лимит памяти: {device.memory_limit()} байт\")\n",
" print(f\"🧮 Лимит вычислительных блоков: {device.compute_units_limit()}\")\n",
" print(f\"📚 Размер кэша модели: {device.model_cache_size()}\")\n",
" \n",
" # Очистка кэша\n",
" device.cleanup_cache()\n",
" print(\"🧹 Кэш очищен\")\n",
" \n",
" except Exception as e:\n",
" print(f\"❌ Ошибка операции устройства CoreML: {e}\")\n",
"else:\n",
" print(\"⚠️ Пропускаем операции устройства, так как CoreML недоступен\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Конфигурация бэкенда CoreML"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"if coreml_available:\n",
" try:\n",
" # Создать конфигурацию бэкенда CoreML\n",
" config = rustorch.CoreMLBackendConfig(\n",
" enable_caching=True,\n",
" max_cache_size=200,\n",
" enable_profiling=True,\n",
" auto_fallback=True\n",
" )\n",
" print(f\"⚙️ Конфигурация бэкенда: {config}\")\n",
" \n",
" # Проверить и изменить значения конфигурации\n",
" print(f\"📊 Включить кэширование: {config.enable_caching}\")\n",
" print(f\"🗂️ Максимальный размер кэша: {config.max_cache_size}\")\n",
" print(f\"📈 Включить профилирование: {config.enable_profiling}\")\n",
" print(f\"🔄 Автоматический откат: {config.auto_fallback}\")\n",
" \n",
" # Изменить конфигурацию\n",
" config.enable_profiling = False\n",
" config.max_cache_size = 150\n",
" print(f\"\\n🔧 Обновленная конфигурация: {config}\")\n",
" \n",
" # Создать бэкенд CoreML\n",
" backend = rustorch.CoreMLBackend(config)\n",
" print(f\"🚀 Бэкенд CoreML: {backend}\")\n",
" print(f\"✅ Бэкенд доступен: {backend.is_available()}\")\n",
" \n",
" # Получить статистику бэкенда\n",
" stats = backend.get_stats()\n",
" print(f\"📊 Статистика бэкенда: {stats}\")\n",
" print(f\" Всего операций: {stats.total_operations}\")\n",
" print(f\" Попадания в кэш: {stats.cache_hits}\")\n",
" print(f\" Промахи кэша: {stats.cache_misses}\")\n",
" print(f\" Операции отката: {stats.fallback_operations}\")\n",
" print(f\" Процент попаданий в кэш: {stats.cache_hit_rate():.2%}\")\n",
" print(f\" Процент откатов: {stats.fallback_rate():.2%}\")\n",
" print(f\" Среднее время выполнения: {stats.average_execution_time_ms:.2f}мс\")\n",
" \n",
" # Очистка кэша\n",
" backend.cleanup_cache()\n",
" print(\"\\n🧹 Кэш бэкенда очищен\")\n",
" \n",
" except Exception as e:\n",
" print(f\"❌ Ошибка операции бэкенда CoreML: {e}\")\n",
"else:\n",
" print(\"⚠️ Пропускаем операции бэкенда, так как CoreML недоступен\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Базовые операции с тензорами (CPU)\n",
"\n",
"Для сравнения с CoreML сначала выполним базовые операции на CPU."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" # Создание базовых тензоров и операции\n",
" print(\"🧮 Базовые операции с тензорами (CPU)\")\n",
" \n",
" # Создать тензоры из массивов NumPy (упрощенный интерфейс)\n",
" data_a = np.random.randn(2, 3).astype(np.float32)\n",
" data_b = np.random.randn(3, 2).astype(np.float32)\n",
" \n",
" print(f\"📐 Форма матрицы A: {data_a.shape}\")\n",
" print(f\"📐 Форма матрицы B: {data_b.shape}\")\n",
" \n",
" # Умножение матриц с NumPy (для сравнения)\n",
" numpy_result = np.matmul(data_a, data_b)\n",
" print(f\"✅ Форма результата matmul NumPy: {numpy_result.shape}\")\n",
" print(f\"📊 Результат (первые элементы): {numpy_result.flatten()[:4]}\")\n",
" \n",
" print(\"\\n🚀 Операции CPU завершены\")\n",
" \n",
"except Exception as e:\n",
" print(f\"❌ Ошибка операции с тензором: {e}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Симуляция сравнения производительности"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import time\n",
"\n",
"def benchmark_matrix_operations():\n",
" \"\"\"Сравнить производительность с разными размерами матриц\"\"\"\n",
" \n",
" sizes = [(64, 64), (128, 128), (256, 256), (512, 512)]\n",
" \n",
" print(\"🏁 Сравнение производительности:\")\n",
" print(\"Размер\\t\\tВремя CPU (мс)\\tОжидаемый CoreML (мс)\")\n",
" print(\"-\" * 58)\n",
" \n",
" for size in sizes:\n",
" # Измерить время выполнения CPU\n",
" a = np.random.randn(*size).astype(np.float32)\n",
" b = np.random.randn(size[1], size[0]).astype(np.float32)\n",
" \n",
" start_time = time.time()\n",
" result = np.matmul(a, b)\n",
" cpu_time = (time.time() - start_time) * 1000\n",
" \n",
" # Ожидаемое время CoreML (гипотетическое)\n",
" # В реальной реализации использовать фактические измерения бэкенда CoreML\n",
" expected_coreml_time = cpu_time * 0.6 # Предположение: CoreML на 40% быстрее\n",
" \n",
" print(f\"{size[0]}x{size[1]}\\t\\t{cpu_time:.2f}\\t\\t{expected_coreml_time:.2f}\")\n",
"\n",
"benchmark_matrix_operations()\n",
"\n",
"print(\"\\n📝 Примечание: Времена CoreML гипотетические. Реальные значения зависят от конкретной реализации.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Симуляция выбора устройства"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def simulate_device_selection():\n",
" \"\"\"Симулировать умный выбор устройства\"\"\"\n",
" \n",
" operations = [\n",
" (\"Умножение маленькой матрицы\", (16, 16), \"CPU\"),\n",
" (\"Умножение средней матрицы\", (128, 128), \"Metal GPU\"),\n",
" (\"Умножение большой матрицы\", (512, 512), \"CoreML\" if coreml_available else \"Metal GPU\"),\n",
" (\"Функция активации\", (32, 64, 128, 128), \"Metal GPU\"),\n",
" (\"Маленькая свертка\", (1, 3, 32, 32), \"CPU\"),\n",
" (\"Большая свертка\", (16, 64, 224, 224), \"CoreML\" if coreml_available else \"Metal GPU\"),\n",
" (\"Операции с комплексными числами\", (128, 128), \"Metal GPU\"), # CoreML не поддерживается\n",
" (\"Статистическое распределение\", (1000,), \"CPU\"), # CoreML не поддерживается\n",
" ]\n",
" \n",
" print(\"🎯 Симуляция умного выбора устройства:\")\n",
" print(\"Операция\\t\\t\\tФорма тензора\\t\\tВыбранное устройство\")\n",
" print(\"-\" * 78)\n",
" \n",
" for name, shape, device in operations:\n",
" shape_str = \"x\".join(map(str, shape))\n",
" print(f\"{name:<31}\\t{shape_str:<15}\\t{device}\")\n",
" \n",
" print(\"\\n📝 Логика выбора:\")\n",
" print(\" • Маленькие операции: CPU (избежать накладных расходов)\")\n",
" print(\" • Средние операции: Metal GPU (сбалансированный)\")\n",
" print(\" • Большие операции: CoreML (оптимизированный)\")\n",
" print(\" • Неподдерживаемые операции: откат GPU/CPU\")\n",
"\n",
"simulate_device_selection()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Практический пример: простой слой нейронной сети"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def simulate_neural_network_layer():\n",
" \"\"\"Симулировать слой нейронной сети\"\"\"\n",
" \n",
" print(\"🧠 Симуляция слоя нейронной сети:\")\n",
" \n",
" # Размер партии и конфигурация слоя\n",
" batch_size = 32\n",
" input_features = 784 # 28x28 MNIST\n",
" hidden_features = 256\n",
" output_features = 10 # 10 классов\n",
" \n",
" print(f\"📊 Размер партии: {batch_size}\")\n",
" print(f\"🔢 Входные признаки: {input_features}\")\n",
" print(f\"🧮 Скрытые признаки: {hidden_features}\")\n",
" print(f\"🎯 Выходные признаки: {output_features}\")\n",
" \n",
" # Симуляция прямого прохода\n",
" steps = [\n",
" (\"Вход → Скрытый\", f\"({batch_size}, {input_features}) @ ({input_features}, {hidden_features})\", \"CoreML\" if coreml_available else \"Metal\"),\n",
" (\"Активация ReLU\", f\"({batch_size}, {hidden_features})\", \"Metal\"),\n",
" (\"Скрытый → Выход\", f\"({batch_size}, {hidden_features}) @ ({hidden_features}, {output_features})\", \"CoreML\" if coreml_available else \"Metal\"),\n",
" (\"Softmax\", f\"({batch_size}, {output_features})\", \"CPU\"),\n",
" ]\n",
" \n",
" print(\"\\n🔄 Симуляция прямого прохода:\")\n",
" total_time = 0\n",
" \n",
" for step, shape, device in steps:\n",
" # Виртуальное время выполнения (мс)\n",
" if device == \"CoreML\":\n",
" time_ms = np.random.uniform(0.5, 2.0)\n",
" elif device == \"Metal\":\n",
" time_ms = np.random.uniform(1.0, 3.0)\n",
" else: # CPU\n",
" time_ms = np.random.uniform(0.2, 1.0)\n",
" \n",
" total_time += time_ms\n",
" print(f\" {step:<15} {shape:<30} {device:<8} {time_ms:.2f}мс\")\n",
" \n",
" print(f\"\\n⏱️ Общее время прямого прохода: {total_time:.2f}мс\")\n",
" print(f\"🚀 Расчетная пропускная способность: {1000/total_time:.0f} партий/секунду\")\n",
"\n",
"simulate_neural_network_layer()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Резюме и следующие шаги"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"📋 Резюме интеграции CoreML RusTorch:\")\n",
"print()\n",
"print(\"✅ Завершенные элементы:\")\n",
"print(\" • Настройка среды Jupyter\")\n",
"print(\" • Создание ядра Rust и Python bindings\")\n",
"print(\" • Проверка доступности CoreML\")\n",
"print(\" • Управление устройствами и конфигурация\")\n",
"print(\" • Статистика и профилирование бэкенда\")\n",
"print(\" • Умный выбор устройства\")\n",
"print()\n",
"print(\"🚧 Будущее развитие:\")\n",
"print(\" • Реальная реализация операций CoreML\")\n",
"print(\" • Бенчмаркинг производительности\")\n",
"print(\" • Больше функций активации и типов слоев\")\n",
"print(\" • Улучшения обработки ошибок\")\n",
"print(\" • Оптимизация памяти\")\n",
"print()\n",
"print(\"🎯 Рекомендуемые следующие шаги:\")\n",
"print(\" 1. Загрузить и протестировать реальные модели CoreML\")\n",
"print(\" 2. Сравнить производительность Metal и CoreML\")\n",
"print(\" 3. Протестировать с реальными рабочими процессами глубокого обучения\")\n",
"print(\" 4. Оценить в производственной среде\")\n",
"\n",
"if coreml_available:\n",
" print(\"\\n🎉 Поздравляем! CoreML доступен и все функции можно протестировать.\")\n",
"else:\n",
" print(\"\\n⚠️ CoreML недоступен, но базовые функции работают.\")\n",
" print(\" Рекомендуем собрать с включенными функциями CoreML на macOS.\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}