развитие искусственного интеллекта

алгоритм глубокого обучения

Глубокое обучение — это метод машинного обучения, основанный на искусственных нейронных сетях, который использует многослойные нейронные сети для автоматического изучения характеристик данных. Ниже приведены несколько распространенных алгоритмов глубокого обучения:

1. Нейронная сеть прямого распространения (FNN).

Нейронные сети с прямой связью — это самая базовая архитектура глубокого обучения, в которой данные проходят через сеть в одном направлении, не образуя петель. FNN очень эффективен для решения задач классификации и регрессии.

2. Сверточная нейронная сеть (CNN).

CNN — это сеть глубокого обучения, специально разработанная для обработки данных изображений. Он использует сверточные слои для автоматического извлечения пространственных характеристик изображений. Его часто используют для таких задач, как классификация изображений и обнаружение объектов.

3. Рекуррентная нейронная сеть (RNN).

RNN может обрабатывать данные последовательности, такие как временные ряды, языковые модели и т. д. Он использует структуру цикла, позволяющую сети запоминать предыдущие входные данные, и широко используется в распознавании речи, обработке естественного языка и т. д.

Длинная краткосрочная память (LSTM)

LSTM — это улучшенная версия RNN, которая решает проблему долгосрочных зависимостей в традиционной RNN, позволяя сохранять ключевую информацию в более длинных последовательностях.

4. Автоэнкодер

Автоэнкодеры — это метод обучения без учителя, используемый для уменьшения размерности и шумоподавления данных. Он сжимает входные данные в малоразмерный скрытый слой, а затем пытается восстановить исходные данные.

5. Генеративно-состязательная сеть (GAN)

GAN состоит из генератора, который пытается генерировать реалистичные данные, и дискриминатора, который пытается различать реальные и сгенерированные данные. GAN широко используется в таких задачах, как генерация изображений и передача стилей.

6. Transformer

Трансформер — это модель, основанная на механизме внимания, который особенно эффективен при обработке естественного языка. Он способен обрабатывать данные длинных последовательностей и быстрее обучается по сравнению с RNN.

Платформа машинного обучения TensorFlow

1. Основное определение и структура

TensorFlowЭто платформа машинного обучения с открытым исходным кодом, разработанная командой Google Brain. Он использует концепцию графов потоков данных, позволяющую разработчикам создавать сложные нейронные сети. Его название происходит от «Flow» (поток) или «Тензор» (многомерный массив) в графе операции.

2. Основные компоненты и уровни

TensorFlow спроектирован в несколько уровней, чтобы сбалансировать гибкость и эффективность разработки:

Keras API：Высокоуровневый интерфейс предоставляет простой синтаксис для построения и обучения моделей, подходящий для большинства сценариев разработки.
Eager Execution：Режим мгновенного выполнения, запущенный по умолчанию, позволяет выполнять программный код построчно, как обычную программу Python, что упрощает отладку.
TensorFlow Core：Низкоуровневый API, который позволяет разработчикам точно контролировать математические операции и тензорную обработку.

3. Жизненный цикл разработки модели

Типичный процесс разработки модели в TensorFlow выглядит следующим образом:

этап	иллюстрировать
Подготовка данных	использовать`tf.data`API для чтения, очистки и предварительной обработки данных.
Построить модель	через`tf.keras.Sequential`или Функциональный API для определения сетевого уровня.
Составление и обучение	Установите оптимизатор (Optimizer) и функцию потерь (Loss Function) и выполните`model.fit()`。
Оценка и развертывание	Проверьте точность модели и экспортируйте ее как`SavedModel`формат для развертывания.

4. Основные преимущества и применение

Кроссплатформенное развертывание:Поддерживает развертывание с сервера (TF Serving), мобильного устройства (TF Lite) в браузере (TF.js).
Высокопроизводительные вычисления:Поддерживает процессор, графический процессор и эксклюзивное аппаратное ускорение TPU от Google.
Сильная экосистема:Он включает в себя инструмент визуализации TensorBoard, библиотеку моделей TensorFlow Hub и центр сбора и распространения данных TensorFlow Datasets.

5. Простой пример кода

Ниже приведен пример построения простой модели линейной регрессии с использованием Keras:

импортировать тензорный поток astf
импортировать numpy как np

# Построить модель
модель = tf.keras.Sequential([
    tf.keras.layers.Dense(units=1, input_shape=[1])
])

# Компилируем модель
model.compile(optimizer='sgd', loss='mean_squared_error')

# Подготовьте тестовые данные
xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

#Модель поезда
model.fit(xs, ys, эпох=500, подробный=0)

# Делайте прогнозы
print("Результат прогноза:", model.predict([10.0]))

API глубокого обучения Keras

1. Базовое определение и позиционирование

Keras— это API нейронной сети высокого уровня, написанный на Python и предназначенный для быстрого экспериментирования. Первоначально он был разработан Франсуа Шолле и теперь доступен какTensorFlowОфициальный интерфейс высокого уровня (tf.keras). Основные принципы проектирования Keras удобны для пользователя, модульны и легко расширяются, что позволяет разработчикам создавать модели глубокого обучения с минимальным написанием кода.

2. Основная концепция дизайна

Простота использования:Уделяйте приоритетное внимание опыту разработчиков и инкапсулируйте общие компоненты глубокого обучения в простые функции.
Модуляризация:Модели рассматриваются как независимые, полностью настраиваемые последовательности слоев, потерь, оптимизаторов и т. д.
Поддержка нескольких серверных частей:Хотя в настоящее время Keras 3 глубоко интегрирован с TensorFlow, он уже поддерживает одновременную работу на TensorFlow, PyTorch и JAX.

3. Три способа построения модели.

Способ	Функции	Применимые сценарии
Sequential API	Просто слой за слоем, один за другим.	Модель линейного стека с одним входом и одним выходом.
Functional API	Может определять сложную графику и поддерживать несколько входов/выходов.	Остаточная сеть (ResNet), многофилиальная модель.
Subclassing	по наследству`Model`Пользовательское поведение категории.	Сценарии НИОКР, требующие полного контроля над логикой прямого распространения.

4. Стандартный процесс разработки

Выполнение задачи машинного обучения в Keras обычно включает в себя следующие пять шагов:

Определите модель:Постройте архитектуру модели и добавьте скрытые слои.
Скомпилируйте модель:Укажите оптимизатор (например, Adam), функцию потерь (например, CrossEntropy) и метрики оценки.
Модель обучения:использоватьfit()Функция передает данные для обучения.
Модель оценки:использоватьevaluate()Проверьте производительность на тестовом наборе.
предсказывать:использоватьpredict()Получение результатов прогнозирования для новых данных.

5. Примеры кода

Ниже приведен стандартный способ использования Keras для создания простой сети классификации изображений (например, MNIST):

из tensorflow.keras импортировать слои, модели

# 1. Определить последовательную модель
модель = модели.Последовательные([
    Layers.Flatten(input_shape=(28, 28)), #Входной слой
    Layers.Dense(128, active='relu'), # Скрытый слой
    Layers.Dropout(0.2), # Предотвратить переобучение
    Layers.Dense(10,activation='softmax') # Выходной слой
])

# 2. Компилировать
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              метрики=['точность'])

# 3. Обучение (при условии, что x_train, y_train уже существует)
# model.fit(x_train, y_train, epochs=5)

6. Связь между Keras и TensorFlow

Начиная с TensorFlow 2.0, Keras является его API высокого уровня по умолчанию. Это означает, что вы можете использовать простой синтаксис Keras, одновременно используя преимущества базового распределенного обучения TensorFlow, ускорения TPU и мощных возможностей развертывания (таких как обслуживание TensorFlow).

Основные компоненты слоя Keras

1. Основное определение

В Керасе,LayerЭто базовая единица построения нейронных сетей. Каждый уровень инкапсулирует определенную логику вычислений (например, умножение матриц) и статус (весовой вес).weights). Модель по существу соединяет несколько уровней, образуя структуру потока данных.

2. Сравнительная таблица типов основных слоев

категория	Часто используемые слои (tf.keras.layers)	Основные функции
Базовый слой (ядро)	`Dense`	Полносвязный слой, выполните $y = f(Wx + b)$.
Сверточный слой	`Conv2D`, `Conv1D`	Используется для извлечения признаков, часто используется в изображениях или временных рядах.
Слой объединения (Pooling)	`MaxPooling2D`, `AveragePooling2D`	Уменьшите размерность и сократите объем вычислений, сохранив при этом ключевые функции.
Рекуррентный слой (Рекуррентный)	`LSTM`, `GRU`, `SimpleRNN`	Обрабатывает последовательность данных (например, текст, цены на акции) и имеет память.
Уровень регуляризации (Регуляризация)	`Dropout`, `BatchNormalization`	Предотвратите переоснащение и ускорьте конвергенцию.

3. Описание важных параметров

units / filters：Размерность вывода (количество нейронов) или количество ядер свертки.
activation：Функция активации (например,'relu', 'sigmoid', 'softmax'), определяет нелинейное преобразование вывода.
input_shape：Его необходимо определить только на первом уровне модели, чтобы сообщить модели размеры входных данных.
kernel_initializer：Определите, как инициализируются веса.

4. Общие операции и вспомогательные слои

Помимо слоев для расчета признаков, существуют еще специальные слои для преобразования структур данных:

Flatten：Сгладьте многомерные входные данные (например, изображение 28x28) в одномерный вектор.
Reshape：Настраивает ввод на указанную форму.
Concatenate：Используется с функциональным API для объединения результатов нескольких слоев.

5. Пример реализации кода

Ниже показано, как различные слои работают вместе в модели обработки изображений:

из tensorflow.keras импортировать слои, модели

модель = модели.Последовательные([
    # Слой свертки извлекает пространственные объекты
    Layers.Conv2D(32, (3, 3), активация = 'relu', input_shape = (64, 64, 3)),
    # Функции сжатия слоев пула
    Layers.MaxPooling2D((2, 2)),
    # Выравнивающий слой готов к полному соединению
    слои.Сгладить(),
    # Полностью подключенный слой для обучения
    Layers.Dense(64, активация = 'relu'),
    # Dropout для предотвращения переобучения
    слои.Выпадение(0,5),
    # Выходной слой (при условии, что 10 категорий)
    Layers.Dense(10, активация = 'softmax')
])

6. Расчет весов и параметров

Каждый слой имеет обучаемые параметры (Trainable Params). НапримерDense(units=10)Если входная размерность равна 50, количество параметров равно $50 \times 10$ (вес) + $10$ (смещение) = $510$. Вы можете использоватьmodel.summary()для просмотра распределения параметров каждого слоя.

Нейронная сеть прямого распространения Keras

1. Базовое определение FNN

Нейронная сеть прямого распространения (FNN) — это самая базовая архитектура, подобная нейронной сети. Данные поступают из входного слоя, подвергаются вычислениям в одном или нескольких скрытых слоях и, наконец, выводят результаты из выходного слоя. Поток данных всегда прямой, без петель и путей обратной связи.

2. Создайте пример модели FNN.

Используйте следующееtf.keras.SequentialСоздайте стандартный многослойный перцептрон (MLP), подходящий для классификации структурированных данных (например, набора данных Iris или прогнозирования цен на жилье):

из tensorflow.keras импортировать слои, модели

Защиту build_fnn_model (input_dim, num_classes):
    модель = модели.Последовательные([
        # Входной слой и первый скрытый слой
        Layers.Dense(64, активация='relu', input_shape=(input_dim,)),
        
        #Второй скрытый слой
        Layers.Dense(32, активация = 'relu'),
        
        # Слой регуляризации (необязательно), чтобы уменьшить переобучение
        слои.Выпадение(0.2),
        
        # Выходной слой (softmax используется для мультиклассификации, а линейный обычно добавляется для регрессии)
        Layers.Dense (num_classes, активация = 'softmax')
    ])
    возвратная модель

# Предположим, что имеется 20 входных признаков и 3 категории целей классификации.
модель = build_fnn_model(input_dim=20, num_classes=3)
модель.сводка()

3. Составление и выполнение модели.

При составлении необходимо выбрать соответствующую функцию потерь (Loss Function) согласно типу задачи:

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              метрики=['точность'])

# Выполнить обучение
# model.fit(x_train, y_train, epochs=50, Batch_size=32, validation_split=0.2)

4. Таблица сравнения ключевых компонентов FNN

Имя компонента	Часто используемые настройки	Описание функции
Плотный (полностью связный слой)	`units=64`	Соедините все нейроны предыдущего слоя с этим слоем, чтобы изучить нелинейные комбинации функций.
ReLU (функция активации)	`activation='relu'`	Решение проблемы исчезающего градиента в настоящее время является наиболее часто используемой функцией активации скрытых слоев.
Softmax (функция вывода)	`activation='softmax'`	Преобразуйте выходные данные в распределение вероятностей так, чтобы сумма всех вероятностей классов была равна 1.
Адам (оптимизатор)	`optimizer='adam'`	Алгоритмы, которые автоматически регулируют скорость обучения, обычно могут обеспечить более быструю и стабильную сходимость.

5. Сценарии применения и ограничения

Применимые сценарии:Обработка табличных данных (табличные данные), простая классификация объектов и выполнение функций окончательного уровня принятия решений в сложных моделях (таких как CNN, RNN).
ограничение:Он не может эффективно обрабатывать данные с пространственными отношениями (изображения) или временным порядком (речь), поскольку предполагает, что входные объекты независимы друг от друга.
Напоминание о размерах:Если вы столкнетесьValueError: Input 0 of layer dense is incompatible with the layer, пожалуйста, используйтеtraceback.format_exc()Проверьте, совпадает ли форма входных данныхinput_shapeопределение.

Пример Кераса CNN

1. Описание базовой архитектуры CNN

Сверточная нейронная сеть (CNN) в основном состоит из сверточного слоя (сверточного слоя), уровня пула (уровня пула) и полностью связного слоя (плотного слоя). Сверточный уровень отвечает за извлечение пространственных характеристик изображения, уровень объединения отвечает за уменьшение размерности данных и, наконец, полностью связный уровень принимает решения о классификации.

2. Создайте пример модели CNN.

Используйте следующееtf.keras.SequentialСоздайте классическую модель CNN, подходящую для задач классификации изображений, таких как MNIST или CIFAR-10:

из tensorflow.keras импортировать слои, модели

Защиту build_cnn_model (input_shape, num_classes):
    модель = модели.Последовательные([
        # Первый набор свертки и объединения: извлечение основных функций
        Layers.Conv2D(32, (3, 3), активация = 'relu', input_shape = input_shape),
        Layers.MaxPooling2D((2, 2)),
        
        # Второй набор свертки и объединения: извлечение функций высокого порядка
        Layers.Conv2D(64, (3, 3), активация = 'relu'),
        Layers.MaxPooling2D((2, 2)),
        
        # Третий набор извилин: дальнейшее усиление функций
        Layers.Conv2D(64, (3, 3), активация = 'relu'),
        
        # Сглаживание и полностью связанные слои: конвертируйте карты объектов в результаты классификации.
        слои.Сгладить(),
        Layers.Dense(64, активация = 'relu'),
        Layers.Dense (num_classes, активация = 'softmax')
    ])
    возвратная модель

# Постройте модель (при условии, что входное изображение имеет размер 28x28 в оттенках серого и количество категорий равно 10)
модель = build_cnn_model(input_shape=(28, 28, 1), num_classes=10)
модель.сводка()

3. Составление и обучение модели.

После построения модели необходимо указать оптимизатор, функцию потерь и показатели оценки. Для задач мультиклассификации обычно используютAdamОптимизатор иSparseCategoricalCrossentropy。

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              метрики=['точность'])

# Предположим, что уже есть подготовленные обучающие данные x_train, y_train
# model.fit(x_train, y_train, epochs=10, Batch_size=64)

4. Сравнительная таблица функций ключевого слоя

Имя слоя	Примеры ключевых параметров	Основная функция
Conv2D	`filters=32, kernel_size=(3,3)`	С помощью ядер свертки и операций с изображениями извлекаются локальные элементы, такие как края и текстуры.
MaxPooling2D	`pool_size=(2,2)`	Выберите максимальное значение региона и уменьшите разрешение, чтобы уменьшить объем вычислений и избежать переобучения.
Flatten	никто	Сгладьте многомерный тензор в одномерный вектор, чтобы ввести окончательный классификатор.
Dense	`units=10, activation='softmax'`	Сопоставьте извлеченные признаки с вероятностями конкретных классов.

5. Рекомендации по отладке и оптимизации производительности.

Обработка переоснащения:Может быть добавлен перед полностью связанным слоем.layers.Dropout(0.5), случайным образом отбрасывая нейроны для повышения способности к обобщению.
Улучшение данных:использоватьtf.keras.layers.RandomFlipДругие слои автоматически поворачивают или переворачивают изображения во время обучения, чтобы увеличить разнообразие выборок.
Обнаружение ошибок:Если тренировка прервана, используйтеtraceback.format_exc()Проверьте несоответствие размеров тензора (формы) или наличие нехватки памяти (OOM).

Рекуррентная нейронная сеть Keras RNN

1. Основные концепции RNN

Рекуррентная нейронная сеть (RNN) специально используется для обработкиданные последовательности, например временные ряды, речь или естественный язык. В отличие от FNN, RNN обладает способностью «памяти». Нейроны скрытого слоя передадут текущую информацию на следующий временной шаг (временной шаг), тем самым фиксируя контекстную корреляцию в данных.

2. Создайте пример модели RNN.

В практических приложениях, чтобы избежать проблемы «исчезающего градиента», вызванной длинными последовательностями, мы обычно используемLSTMилиGRUслои. Следующее строит простую модель LSTM для прогнозирования временных рядов (например, цен на акции или температуры):

из tensorflow.keras импортировать слои, модели

def build_rnn_model (временные шаги, особенности):
    модель = модели.Последовательные([
        # Слой LSTM: требуется ввод 3D (образцы, временные шаги, функции)
        Layers.LSTM(50, активация = 'relu', input_shape = (временные шаги, функции), return_sequences = True),
        
        # LSTM второго уровня: если последовательность не возвращается, return_sequences=False (по умолчанию)
        Layers.LSTM(50, активация = 'relu'),
        
        # Полностью подключенный слой для окончательного вывода
        слои.Плотный(25),
        Layers.Dense(1) # Предполагая, что это проблема регрессии, спрогнозируйте следующее значение
    ])
    возвратная модель

# Предположим, что наблюдаются данные за последние 10 дней, и в день имеется 5 функций
модель = build_rnn_model (временные шаги = 10, функции = 5)
модель.сводка()

3. Описание измерения данных

Слой RNN для входных данныхShapeТребования очень строгие, и именно здесь новички чаще всего сообщают об ошибках:

Название измерения	иллюстрировать	пример
Samples	Общее количество обучающих выборок.	1000 записей
Timesteps	Длина последовательности (временного окна).	Наблюдайте за прошедшими 30 днями
Features	Количество функций в каждый момент времени.	Цена открытия, цена закрытия, объем торгов

4. Часто используемая сравнительная таблица уровней цикла

Имя слоя	Функции	Предлагаемые сценарии
SimpleRNN	Самая простая структура, быстрая работа, но очень короткая память.	Очень короткие последовательности или простые шаблоны.
LSTM	Он имеет механизм ворот и может сохранять долговременную память.	Обработка длинного текста, прогнозирование сложных временных рядов.
GRU	Упрощенная версия LSTM с меньшим количеством параметров и более быстрым обучением.	Альтернатива LSTM, когда вычислительные ресурсы ограничены.

5. Рекомендации по обучению и отладке

Градиентная обрезка:RNN склонен к градиентному взрыву. Добавляется при компиляции оптимизатораclipnorm=1.0Может повысить стабильность.
Последовательность возврата:При объединении нескольких слоев RNN все предыдущие слои, кроме последнего, должны быть установлены.return_sequences=True。
Устранение неполадок исключений:Если вы столкнетесьInput 0 of layer lstm is incompatible with the layer, пожалуйста, передайтеtraceback.format_exc()исследоватьX_train.shapeДействительно ли это трехмерный тензор.

# Пример компиляции
model.compile(optimizer='adam', loss='mean_squared_error')

Прогнозирование временных рядов Keras LSTM

1. Базовая архитектура LSTM

Длинная краткосрочная память (LSTM) — это особый тип RNN, изначально разработанный для решения проблемы исчезающего градиента, которая возникает, когда традиционная RNN обрабатывает длинные последовательности. Он использует «механизм шлюзов» (ворота забывания, входные ворота, выходные ворота) для управления сохранением и удалением информации, что позволяет фиксировать долгосрочные зависимости в данных.

2. Создайте пример модели LSTM.

Ниже представлена двухуровневая составная модель LSTM, которая часто используется для прогнозирования цен на акции, прогнозирования энергетической нагрузки или анализа данных метеорологического зондирования:

из tensorflow.keras импортировать слои, модели

def build_lstm_model (временные шаги, особенности):
    модель = модели.Последовательные([
        # Первый уровень LSTM: return_sequences=True должен быть установлен для передачи последовательности на следующий уровень
        Layers.LSTM(units=50, return_sequences=True, input_shape=(временные шаги, функции)),
        Layers.Dropout(0.2), # Предотвратить переобучение
        
        # Второй уровень LSTM: последний уровень обычно не возвращает последовательность
        Layers.LSTM(единицы=50, return_sequences=False),
        слои.Выпадение(0.2),
        
        # Полностью подключенный выход слоя
        Layers.Dense(units=1) # Прогнозируем одно значение
    ])
    
    model.compile(optimizer='adam', loss='mean_squared_error')
    возвратная модель

# Пример: просмотрите 60 моментов времени в прошлом, каждый момент имеет 1 признак (например, цену).
модель = build_lstm_model (временные шаги = 60, функции = 1)
модель.сводка()

3. Преобразование измерений данных (изменение формы)

Входные данные для LSTM должны быть трехмерным тензором.(Samples, Timesteps, Features). Прежде чем подавать данные в модель, часто необходимо использовать NumPy для преобразования:

импортировать numpy как np

# Предположим, что исходные данные представляют собой одномерную последовательность
данные = np.random.rand(1000, 1)

# Преобразование в (количество выборок, временные шаги, количество функций)
#Пример: 1 прогноз на каждые 60 прогнозов
X_train = []
для я в диапазоне (60, 1000):
    X_train.append(данные[i-60:i, 0])
X_train = np.array(X_train)
X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))

4. Описание основных параметров

Имя параметра	иллюстрировать
units	Количество нейронов в скрытом слое представляет собой объем памяти модели.
return_sequences	Если`True`, вывести всю последовательность; если`False`, выводится только последний временной шаг.
input_shape	Формат:`(продолжительность, количество функций)`, не включает количество выборок.
Dropout	Случайная установка некоторых единиц в 0 во время обучения может эффективно снизить риск переобучения модели.

5. Рекомендации по отладке

Размеры не совпадают:Если сообщается об ошибкеexpected ndim=3, found ndim=2, пожалуйста, проверьте, прошли ли входные данныеreshapeПреобразование в 3D.
Убыток не падает:Временные ряды чувствительны к числовому диапазону, обязательно используйтеMinMaxScalerМасштабируйте данные от 0 до 1.
Программа вылетает:Если у вас недостаточно памяти, уменьшитеbatch_sizeили используйтеtraceback.format_exc()Проверьте конкретную причину ошибки.

Автоэнкодер Керас

1. Основные понятия автоэнкодеров

Автоэнкодер — этообучение без присмотраНейронная сеть предназначена для сжатия входных данных в низкоразмерное представление (кодирование), а затем восстановления из них исходных данных (декодирование). В основном он состоит из двух частей:

Кодировщик:Отвечает за извлечение функций и сжатие размерности.
Декодер:Отвечает за восстановление исходных входных данных из сжатых объектов.

2. Создайте простой пример автокодировщика.

Ниже используется функциональный API Keras для создания базового автокодировщика для шумоподавления или уменьшения размерности изображения:

из tensorflow.keras импортировать слои, модели

#Установим входной размер (предполагается, что это изображение 28x28 после выравнивания)
input_dim = 784
coding_dim = 32 #Размер сжатого объекта

# 1. Определить кодировщик
input_img = Layers.Input(shape=(input_dim,))
закодированный = Layers.Dense (encoding_dim, активация = 'relu') (input_img)

#2. Определить декодер (Decoder)
декодированный = Layers.Dense (input_dim, активация = 'сигмоид') (закодированный)

# 3. Постройте модель автоэнкодера (включая входные данные и восстановленные выходные данные)
автоэнкодер = models.Model(input_img, декодировано)

# 4. Создайте отдельную модель кодировщика (для извлечения признаков).
кодировщик = модели.Модель(input_img, закодировано)

# 5. Скомпилируйте модель (обычно используя MSE в качестве функции потерь)
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')

3. Сравнительная таблица распространенных сценариев применения

Тип приложения	Основная цель	Функции
Уменьшение размерности данных	Заменить PCA	Может фиксировать нелинейные характеристики.
Шумоподавление изображения (Шумоподавление)	Удалить шум изображения	Введите зашумленное изображение, и целью будет исходное чистое изображение.
Обнаружение аномалий	Обнаружение мошенничества с кредитными картами и сбоев оборудования	Если ошибка реконструкции (Reconstruction Error) слишком велика, это аномалия.
Создать модель	VAE (вариационный автоэнкодер)	Новый материал может генерироваться случайным образом из пространства кодирования.

4. Глубокие сверточные автоэнкодеры (CAE).

При обработке изображений лучше использовать сверточные слои. Использование кодировщикаConv2DиMaxPooling2D, декодер используетUpSampling2DилиConv2DTranspose：

# Часть кодера
x = Layers.Conv2D(16, (3, 3), активация = 'relu', дополнение = 'тот же') (input_img_2d)
x = Layers.MaxPooling2D((2, 2), дополнение = 'тот же') (x)

#Декодерная часть
x = Layers.Conv2D(16, (3, 3), активация = 'relu', дополнение = 'тот же') (x)
x = Layers.UpSampling2D((2, 2))(x)
декодировано = Layers.Conv2D(1, (3, 3), активация = 'сигмовидная', дополнение = 'тот же') (x)

5. Обучение и мониторинг эффективности

Цели обучения:автоэнкодерy_trainто естьx_trainсам, то естьmodel.fit(x_train, x_train, ...)。
Ошибка реконструкции:Если значение потерь (Loss) остается высоким после обучения, это означаетencoding_dimСлишком мал, чтобы полностью отразить характеристики данных.
Устранение неполадок исключений:Если вы столкнулись с исчезновением градиента или изображение полностью черное, используйтеtraceback.format_exc()Проверьте функцию активации (например, выходной слой должен быть сигмовидным или линейным в зависимости от диапазона данных).

Keras генерирует враждебные сети

1. Основной рабочий механизм GAN

Генеративно-состязательная сеть (GAN) состоит из двух конкурирующих нейронных сетей:

Генератор:Отвечает за генерацию поддельных данных из случайного шума с целью обмануть дискриминатор.
Дискриминатор:Отвечает за определение того, взяты ли входные данные из реального набора данных или являются подделкой, созданной генератором.

Оба развиваются во время обучения: генератор учится создавать более реалистичный материал, а дискриминатор учится становиться более внимательным инспектором. Этот динамический баланс в конечном итоге позволяет генератору создавать высококачественные реалистичные материалы.

2. Установите компоненты модели GAN.

Ниже показана базовая структура GAN для генерации рукописных цифр в стиле MNIST:

из tensorflow.keras импорт слоев, моделей, оптимизаторов

# 1. Определить генератор
защита build_generator(latent_dim):
    модель = модели.Последовательные([
        Layers.Dense(128, input_dim=latent_dim),
        слои.LeakyReLU(альфа=0,2),
        слои.Плотность(256),
        слои.LeakyReLU(альфа=0,2),
        Layers.Dense(784,activation='tanh') # Диапазон вывода: от -1 до 1.
    ])
    возвратная модель

# 2. Определить дискриминатор
защита build_discriminator():
    модель = модели.Последовательные([
        Layers.Dense(256, input_dim=784),
        слои.LeakyReLU(альфа=0,2),
        слои.Выпадение(0.3),
        Layers.Dense(1, active='sigmoid') # Бинарная классификация: истина или ложь
    ])
    model.compile(loss='binary_crossentropy',оптимизатор=optimizers.Adam(0.0002, 0.5))
    возвратная модель

# 3. Определить состязательную сеть (комбинированную модель)
def build_gan (генератор, дискриминатор):
    Discriminator.trainable = False # Исправить дискриминатор в комбинированной модели
    модель = модели.Последовательные([генератор, дискриминатор])
    model.compile(loss='binary_crossentropy',оптимизатор=optimizers.Adam(0.0002, 0.5))
    возвратная модель

3. Сравнительная таблица тренировочного процесса

Обучение GAN отличается от обучения общих моделей. Это требует попеременного обучения дискриминатора и генератора:

этап обучения	Этапы работы	цели обучения
дискриминатор поездов	Введите наполовину настоящие изображения и наполовину поддельные изображения и присвойте им метки (1 и 0).	Максимальная точность определения подлинности.
обучающий генератор	Введите случайный шум через состязательную сеть и установите все теги на 1 (притворитесь настоящим).	Минимизирует вероятность того, что дискриминатор обнаружит подделку.

4. Глубокий сверточный ГАН (DCGAN)

При обработке изображений переключение на сверточные слои позволяет значительно улучшить качество создаваемых изображений. Генератор будет использоватьConv2DTranspose(транспонированная свертка), чтобы увеличить карту объектов:

# Пример транспонированного слоя свертки в генераторе
model.add(layers.Conv2DTranspose(128, (4,4), шаги=(2,2), дополнение='тот же'))
model.add(layers.LeakyReLU(альфа=0.2))

5. Трудности в обучении и предложения

Свернуть режим:Генератор будет производить только очень небольшое количество выборок. Решения включают использование другой функции потерь (например, WGAN) или корректировку скорости обучения.
Равновесие Нэша:Идеальное состояние обучения заключается в том, что вероятность принятия решения дискриминатором стабильна и равна 0,5. Если дискриминатор слишком силен, генератор не сможет обучаться.
Отладка и протоколирование:использоватьtraceback.format_exc()Перехват исключений в циклах обучения. Рекомендуется периодически сохранять изображения, созданные генератором, чтобы наблюдать за визуальной эволюцией.

Модель трансформатора Керас

1. Механизм сердечника трансформатора

Трансформатор — это метод, который отказывается от традиционной структуры цикла RNN и полностью основан наМеханизм вниманияархитектура. Его ядро лежит в «уровне многоголового самообслуживания», который может обрабатывать все позиции в последовательности одновременно, прекрасно решая проблему зависимости на больших расстояниях, и является краеугольным камнем современных больших моделей, таких как BERT и GPT.

2. Создайте блок-трансформер.

В Keras мы обычно инкапсулируем основной модуль Transformer в специальный слой или функцию. Стандартный блок трансформатора включает в себя многоголовочное внимание, сложение и нормализацию (Add & Norm), а также сеть прямой связи (Feed Forward).

из тензорного потока импорта кераса
из слоев импорта tensorflow.keras

def Transformer_encoder (входы, head_size, num_heads, ff_dim, dropout = 0):
    № 1. Многоголовое внимание к себе
    x = Layers.MultiHeadAttention(
        key_dim=head_size, num_heads=num_heads, dropout=выпадение
    )(входы, входы)
    x = Layers.Dropout(выпадение)(x)
    res = x + inputs # Остаточное соединение
    x = Layers.LayerNormalization(epsilon=1e-6)(res)

    # 2. Сеть прямой связи
    x_ff = Layers.Dense(ff_dim, active="relu")(x)
    x_ff = Layers.Dropout(выпадение)(x_ff)
    x_ff = Layers.Dense(inputs.shape[-1])(x_ff)
    x = x_ff + x # Остаточное соединение
    вернуть слои.LayerNormalization(epsilon=1e-6)(x)

3. Пример полной модели классификации

Ниже показано, как применять Transformer к задачам классификации последовательностей (таким как анализ настроений или классификация временных рядов):

def build_transformer_model(input_shape, head_size, num_heads, ff_dim, num_transformer_blocks, mlp_units, num_classes, dropout=0):
    входы = keras.Input(shape=input_shape)
    х = входы
    
    # Сложите несколько слоев Transformer Encoder
    для _ в диапазоне (num_transformer_blocks):
        x = Transformer_encoder(x, head_size, num_heads, ff_dim, выпадение)

    #Объединение глобальных средних значений и окончательный уровень классификации
    x = Layers.GlobalAveragePooling1D(data_format="channels_last")(x)
    для dim в mlp_units:
        x = Layers.Dense(dim, active="relu")(x)
        x = Layers.Dropout(выпадение)(x)
    
    выходы = Layers.Dense(num_classes, active="softmax")(x)
    вернуть keras.Model(входы, выходы)

#Пример параметров
модель = build_transformer_model(
    input_shape=(100, 64), # 100 временных точек, 64 объекта в каждой точке
    размер_головки=256,
    число_голов = 4,
    ff_dim=4,
    num_transformer_blocks=4,
    mlp_units=[128],
    число_классов = 2,
    отсев = 0,1
)
модель.сводка()

4. Сравнительная таблица ключевых компонентов

Имя компонента	Описание функции
MultiHeadAttention	Рассчитайте силу корреляции между различными позициями в последовательности, чтобы получить контекстную информацию.
Positional Encoding	Из-за параллельной обработки Transformer необходимо добавить дополнительную информацию о местоположении (обычно добавляется во входной слой).
LayerNormalization	Стабилизирует активность нейронов и ускоряет сходимость обучения, что отличается от Batch Norm, обычно используемого в CNN.
Residual Connection	через`x + inputs`Упростите распространение градиентов и предотвратите глубокую деградацию сети.

5. Рекомендации по обучению и отладке

Код местоположения:Если вы обрабатываете последовательные данные (например, текст), необходимо добавить позиционное кодирование, иначе модель будет обрабатывать входные данные как «мешок слов» и терять последовательную информацию.
Потребление памяти:Вычислительная сложность механизма внимания составляет $O(n^2)$ ($n$ — длина последовательности). Если последовательность слишком длинная, легко вызвать OOM.
Устранение неполадок с размерами:Если сообщается об ошибкеIncompatible shapes, обычно возникает при остаточных соединениях. Убедитесь, что после прохождения слоя внимания или плотного слоя выходной размер совпадает с входным.inputsАбсолютно последовательный.

Платформа глубокого обучения PyTorch

1. Основное определение и предыстория

PyTorchЭто платформа машинного обучения с открытым исходным кодом, основанная на библиотеке Torch, в основном разработанная исследовательской группой AI компании Meta (ранее Facebook). Он разработан с учетом приоритетов Python и подчеркивает гибкость и динамику. Он стал самой популярной структурой в академических исследовательских кругах и широко используется в промышленности.

2. Основные функции

Динамические вычислительные графики:В режиме «Определить по-запуску» график расчета строится динамически во время выполнения. Это упрощает отладку и позволяет легко обрабатывать входные данные переменной длины или сложные потоки управления (например, циклы if/for).
Тензорные операции (Тензоры):Обеспечивает операции с многомерными массивами, аналогичные NumPy, но поддерживает мощное ускорение графического процессора.
Автоматическое дифференцирование (Автоград):Встроенный механизм автоматического вывода может автоматически рассчитывать градиент параметров в нейронной сети и упрощать реализацию обратного распространения ошибки.

3. Сравнительная таблица основных компонентов

Имя компонента	Основная цель
torch.nn	Содержит различные слои нейронной сети (например, Linear, Conv2d) и функции потерь.
torch.optim	Предоставляет алгоритмы оптимизации, такие как SGD, Adam и RMSprop.
torch.utils.data	Загрузка данных процесса, включая`Dataset`и`DataLoader`。
torchvision	Набор инструментов, специально разработанный для компьютерного зрения, включая часто используемые наборы данных, архитектуры моделей и преобразования изображений.

4. Стандартный процесс разработки

Разработка модели в PyTorch обычно состоит из следующих шагов:

Подготовьте информацию:наследоватьDatasetкатегория и использованиеDataLoaderВыполните пакетную обработку.
Определите модель:наследоватьnn.Module,существовать__init__Определите слой вforwardОпределите логику прямого распространения в .
Настройте инструменты обучения:Выберите функцию потерь и оптимизатор.
Тренировочный цикл:Выполните прямое распространение, вычислите потери, очистите градиенты, обратное распространение и обновите параметры.

5. Примеры кода

Ниже приведена простая реализация модели линейной регрессии:

импортный фонарь
импортировать torch.nn как nn

# 1. Определить архитектуру модели
класс LinearModel(nn.Module):
    защита __init__(сам):
        супер(LinearModel, self).__init__()
        self.linear = nn.Linear(1, 1) # вход 1, выход 1

    защита вперед (я, х):
        вернуть self.linear(x)

модель = ЛинейнаяМодель()

# 2. Определить функцию потерь и оптимизатор
критерий = nn.MSELoss()
оптимизатор = torch.optim.SGD(model.parameters(), lr=0.01)

# 3. Цикл обучения (упрощенный вариант)
# для входных данных, цели в загрузчике данных:
# выходы = модель(входы)
# потеря = критерий (результаты, цели)
# оптимизатор.zero_grad()
# потеря.назад()
# оптимизатор.шаг()

6. Сравнение с TensorFlow

Грамматический стиль:PyTorch ближе к родному Python и объектно-ориентированному дизайну с интуитивно понятным кодом; TensorFlow (Keras) более инкапсулирован и декларативен.
Экология и инструменты:TensorFlow имеет более зрелые инструменты промышленного развертывания (например, TF Serving); PyTorch занимает абсолютную лидирующую позицию в публикации научных статей и обмене реализациями с сообществом.

PyTorch создает несколько групп классификаторов временных рядов.

Классифицируйте несколько наборов данных временных рядов с помощью модели классификатора архитектуры PyTorch.

Шаг 1: Подготовка данных

Предположим, что несколько наборов данных временных рядов помечены как наборы данных и содержат разные классификационные метки. Нам нужно предварительно обработать данные во что-то подходящее для PyTorch.DatasetиDataLoaderформат обучения и тестирования.

Пример подготовки данных:


        import torch

        from torch.utils.data import DataLoader, Dataset

# Предположим, что каждый набор данных имеет характеристики в несколько моментов времени

        class TimeSeriesDataset(Dataset):

            def __init__(self, data, labels):

                self.data = data

                self.labels = labels

            
            def __len__(self):

                return len(self.data)

            
            def __getitem__(self, idx):

                return torch.tensor(self.data[idx], dtype=torch.float32), torch.tensor(self.labels[idx], dtype=torch.long)

Шаг 2. Постройте модель классификации

Здесь простойСеть длинной краткосрочной памяти (LSTM)Модель для обработки данных временных рядов и классификации окончательных результатов по нескольким категориям. Ниже приведен пример простой модели LSTM.

Пример модели классификации LSTM:


        import torch.nn as nn



        class LSTMClassifier(nn.Module):

            def __init__(self, input_size, hidden_size, num_layers, num_classes):

                super(LSTMClassifier, self).__init__()

                self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)

                self.fc = nn.Linear(hidden_size, num_classes)


            
            def forward(self, x):

                h0 = torch.zeros(num_layers, x.size(0), hidden_size).to(x.device)

                c0 = torch.zeros(num_layers, x.size(0), hidden_size).to(x.device)


                out, _ = self.lstm(x, (h0, c0))

                out = self.fc(out[:, -1, :])

                return out

Шаг 3. Обучите модель

Затем установите функцию потерь и оптимизатор и передайте данные в модель для обучения.

Пример обучения:


        import torch.optim as optim

#Параметры модели
input_size = 10 #Количество объектов в каждый момент времени

        hidden_size = 64

        num_layers = 2
num_classes = 3 #Количество категорий классификации



        model = LSTMClassifier(input_size, hidden_size, num_layers, num_classes)

        criterion = nn.CrossEntropyLoss()

        optimizer = optim.Adam(model.parameters(), lr=0.001)

# цикл обучения

        for epoch in range(num_epochs):

            for inputs, labels in train_loader:

                optimizer.zero_grad()

                outputs = model(inputs)

                loss = criterion(outputs, labels)

                loss.backward()

                optimizer.step()

            print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}')

Шаг 4. Проверьте модель

Оцените производительность модели на тестовых данных.

Тестовый пример:


        model.eval()

        correct = 0

        total = 0



        with torch.no_grad():

            for inputs, labels in test_loader:

                outputs = model(inputs)

                _, predicted = torch.max(outputs, 1)

                total += labels.size(0)

                correct += (predicted == labels).sum().item()

print(f'Точность теста: {100 * правильно/всего:.2f}%')

PyTorch переходит от поддержки процессора к графическому процессору

вопрос

Основная причина, по которой вы обычно не можете включить графический процессор, заключается в том, что установленная вами версия PyTorch+cpuВерсия.

torch ver: 2.9.1+cpu: Это означает, что PyTorch включает поддержку ЦП только при компиляции и вообще не имеет возможности вызывать ядро CUDA.
nvcc: release 13.1: В вашей системе установлены аппаратный драйвер CUDA 13.1 и набор инструментов, но программная часть (PyTorch) к ней не подключена.

Шаг 1. Удалите существующую версию PyTorch для ЦП.

Перед установкой версии с поддержкой графического процессора необходимо сначала удалить существующую версию только с процессором, чтобы избежать конфликтов библиотек:

pip uninstall torch torchvision torchaudio

Шаг 2. Установите версию PyTorch, поддерживающую CUDA.

Если ваша версия CUDA — 13.1, вам необходимо установить соответствующую или совместимую команду PyTorch. Обратите внимание, что PyTorch обычно компилируется для конкретной версии CUDA.

Пожалуйста, выполните следующую команду (установите PyTorch, поддерживающий последнюю версию CUDA):

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

Примечание. На данный момент официальная стабильная версия PyTorch может быть не полностью помечена тегом cu131, но обычно cu124 или последняя скомпилированная версия CUDA могут быть совместимы с драйвером 13.x.

Шаг 3. Убедитесь, что графический процессор включен.

После завершения установки снова запустите сценарий проверки. В случае успеха вы должны увидеть следующие результаты:

torch.cuda.is_available(): True
torch.version.cuda: Отображается как12.4(или версию, которую вы установили)

Общие меры предосторожности

Драйвер NVIDIA:Убедитесь, что на вашем хосте Windows/Linux установлены последние версии драйверов NVIDIA. Наличие NVCC не означает, что драйвер работает правильно.
Ограничения VirtualBox:Если вы находитесь вВиртуальная машина VirtualBoxОбратите внимание, что при запуске Ubuntu вVirtualBox не поддерживает физическую сквозную передачу графического процессора (GPU Passthrough).. Видеокарту NVIDIA хоста нельзя напрямую вызвать на виртуальной машине для выполнения операций CUDA. Если вам необходимо использовать графический процессор, рекомендуется использовать собственную среду Windows или WSL2 (подсистему Windows для Linux).
Поддержка AVX:Если вы видите, что процессор поддерживает AVX: неверно. Некоторые современные платформы глубокого обучения плохо поддерживают старые процессоры, в которых отсутствует набор инструкций AVX, что может привести к снижению производительности или ошибкам, но не связано напрямую с тем, обнаруживает ли это графический процессор.

Transformers

Введение

transformers— это мощный пакет, разработанный Hugging Face и предназначенный для обработки естественного языка (НЛП) и других задач машинного обучения. Он обеспечивает удобное использование множества предварительно обученных моделей, позволяя разработчикам использовать самые передовые технологии с минимальными настройками.

Основные функции

Поддерживает множество предварительно обученных моделей, таких как BERT, GPT, T5 и т. д.
Совместим с фреймворками PyTorch и TensorFlow.
Предоставляет инструменты сегментации слов, обучения модели и точной настройки.
Эффективно обрабатывайте большие наборы данных с помощью библиотеки Datasets.

Способ установки

Можно установить с помощью piptransformersНабор:

pip install transformers

Начинайте быстро

Вот простой пример использования предварительно обученной модели для классификации текста:

из трубопровода импорта трансформаторов

# Загрузка конвейера анализа настроений
классификатор = конвейер("анализ настроений")

# Выполните анализ настроений
results = classifier("Набор Трансформеров Hugging Face просто потрясающий!")
распечатать(результаты)

Общие сценарии применения

Классификация текста:Анализ настроений, обнаружение спама и т. д.
Генерация текста:Языковое моделирование и творческая генерация текста.
Машинный перевод:Перевод текста между несколькими языками.
Вопрос-ответ:Извлекайте ответы из контекста.

в заключение

transformersЭтот пакет является важным инструментом для разработчиков и исследователей в области НЛП. Богатая библиотека моделей и удобный API делают его лучшим выбором для создания и развертывания самых передовых приложений машинного обучения.

Генерация моделей трансформаторов

базовый пример

из импорта трансформеров AutoModelForCausalLM, AutoTokenizer

# Выберите предварительно обученную модель, например GPT-2.
имя_модели = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(имя_модели)
модель = AutoModelForCausalLM.from_pretrained(имя_модели)

# Подсказка ввода
подсказка = "Давным-давно, в далекой стране,"

#Преобразуем входные данные в формат кодировки модели
input_ids = tokenizer.encode(приглашение, return_tensors="pt")

# Используйте модель для генерации текста
вывод = модель.генерировать(
    входные_ид,
    max_length=50, # Максимальное количество сгенерированных слов
    num_return_sequences=1, #Количество возвращенных текстов
    температура=0,7, # Управление разнообразием генерации
    top_k=50, # Ограничить диапазон слов-кандидатов
    top_p=0.9, # Использовать выборку ядра
    do_sample=True # Включить выборку для получения разнообразного вывода
)

# Преобразуем сгенерированную кодировку обратно в текст
сгенерированный_текст = tokenizer.decode(выход[0],skip_special_tokens=True)
печать (сгенерированный_текст)

Описание параметра

max_length：Указывает максимальную длину создаваемого текста.
temperature：Управляет случайностью. Чем ниже значение, тем более сконцентрирована генерация; чем выше значение, тем разнообразнее поколение.
top_k：Ограничивает количество слов-кандидатов, выбранных моделью на каждом этапе. Чем меньше значение, тем более консервативно поколение.
top_p：Используйте метод выборки ядра, чтобы гарантировать, что общая вероятность выбранных слов-кандидатов не превышает заданное значение.
do_sample：Включите генерацию выборки, иначе модель выберет только слово с наибольшей вероятностью.

Простой пример приложения

Креативная генерация текста

подсказка = "В будущей эпохе искусственного интеллекта"
вывод = модель.генерировать(
    tokenizer.encode(приглашение, return_tensors="pt"),
    максимальная_длина = 100,
    температура=1,0,
    top_p=0.95,
    do_sample=Истина
)
print(tokenizer.decode(output[0],skip_special_tokens=True))

Комплектация технической документации

подсказка = "Основной функцией искусственного интеллекта является"
вывод = модель.генерировать(
    tokenizer.encode(приглашение, return_tensors="pt"),
    максимальная_длина = 50,
    температура=0,5,
    do_sample=False # Использовать детерминированную генерацию
)
print(tokenizer.decode(output[0],skip_special_tokens=True))

в заключение

В приведенном выше примере показано, как использоватьtransformersМодель генерации текста. В соответствии с различными потребностями вы можете настроить параметры для создания разнообразного или точного текста, который подходит для творческой генерации, заполнения технической документации и других сценариев.

Измените каталог кеша модели Трансформеров.

Установить каталог кэша

Использование «Обнимающего лица»transformersПри установке пакета предварительно обученные файлы модели и токенизатора будут загружены и сохранены в каталоге кэша по умолчанию. Если вам нужно изменить каталог кэша, вы можете указать его при загрузке модели или токенизатора.cache_dirпараметр.

Пример: изменение каталога кэша модели

из импорта трансформеров AutoModel, AutoTokenizer

# Пользовательский каталог кэша
каталог_кеша = "./my_custom_cache"

# Загружаем модель и токенизатор, указываем директорию кэша
model = AutoModel.from_pretrained("bert-base-uncased",cache_dir=cache_directory)
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased",cache_dir=cache_directory)

Пример: каталог глобального кэша конфигурации.

Вы также можете изменить каталог глобального кэша, задав переменные среды, чтобы все модели и токенизаторы использовали одно и то же местоположение кэша.

импортировать ОС
из трансформеров импорт AutoModel, AutoTokenizer

# Установить каталог глобального кэша
os.environ["TRANSFORMERS_CACHE"] = "./my_global_cache"

# Загрузка модели и токенизатора
модель = AutoModel.from_pretrained("bert-base-uncased")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

Проверьте каталог кэша

Чтобы проверить расположение каталога кэша по умолчанию, вы можете использовать следующий код:

из Transformers.utils импортируйте default_cache_path

print("Каталог кэша по умолчанию:", default_cache_path)

Сценарии применения

Управление пространством:Переместите каталог кэша на диск с большим количеством свободного места.
Изоляция проекта:Настройте отдельные каталоги кэша для разных проектов, чтобы избежать конфликтов ресурсов.
Очистка кэша:Удобно находите файлы кэша для очистки или управления.

в заключение

через настройкиcache_dirили переменные среды, вы можете легко управлять каталогом кэша пакета Transformers, повышая гибкость проекта и эффективность управления ресурсами.

Каталог загрузки модели AI по умолчанию и как его изменить

1. Каталог загрузки по умолчанию.

Модели большинства фреймворков искусственного интеллекта (например, Hugging Face Transformers) сохраняются в заранее заданных каталогах при загрузке для повторного использования. Ниже приведены предустановленные каталоги для некоторых распространенных платформ:

Hugging Face Transformers：Каталог по умолчанию~/.cache/huggingface/transformers/
TensorFlow Hub：Каталог по умолчанию~/.tensorflow_hub/
PyTorch Hub：Каталог по умолчанию~/.cache/torch/hub/

2. Как изменить каталог загрузки по умолчанию

Некоторые файлы моделей имеют большой размер и требуют некоторого управления. Каталог загрузки по умолчанию можно изменить с помощью переменных среды или параметров программы. Вот некоторые конкретные методы:

2.1 Hugging Face Transformers

через переменные средыHF_HOMEилиTRANSFORMERS_CACHEИсправлять.

export HF_HOME=/your/custom/path
export TRANSFORMERS_CACHE=/your/custom/path

Или укажите в программе:

from transformers import AutoModel

import os
os.environ["HF_HOME"] = "/your/custom/path"
os.environ["TRANSFORMERS_CACHE"] = "/your/custom/path"

model = AutoModel.from_pretrained("model-name")

2.2 TensorFlow Hub

Установить переменные средыTFHUB_CACHE_DIR：

export TFHUB_CACHE_DIR=/your/custom/path

Устанавливаем в программе:

import os
os.environ["TFHUB_CACHE_DIR"] = "/your/custom/path"

2.3 PyTorch Hub

Установить переменные средыTORCH_HOME：

export TORCH_HOME=/your/custom/path

Устанавливаем в программе:

import os
os.environ["TORCH_HOME"] = "/your/custom/path"

3. Подтвердите правильность каталога.

Чтобы убедиться, что модель загружена в указанный каталог, вы можете проверить содержимое каталога:

ls /your/custom/path

Или распечатайте текущий каталог в программе:

import os
print(os.environ.get("HF_HOME"))
print(os.environ.get("TRANSFORMERS_CACHE"))

4. Общие меры предосторожности

Убедитесь, что новый каталог имеет достаточные права доступа.
Если переменные среды не вступили в силу, перезагрузите терминал или проверьте правильность настроек.
Некоторым платформам может потребоваться очистить старый каталог и повторно загрузить модель.

Формат файла модели графического процессора

1. Модель FP16 (с плавающей запятой половинной точности)

Тип файла:Стандартный файл модели обнимающего лица (pytorch_model.bin), преобразованный в формат FP16.

использовать:По сравнению с FP32, FP16 снижает использование памяти и повышает производительность вычислений.

Ситуация использования:Обычно используется для вывода графического процессора с помощью PyTorch или TensorFlow.

Как сохранить как FP16:

из импорта трансформаторов AutoModelForCausalLM

модель = AutoModelForCausalLM.from_pretrained("имя_модели")
model.half() # Преобразование в формат FP16
model.save_pretrained("./fp16_model")

2. Модель BF16 (мозг с плавающей точкой)

Тип файла:Похож на FP16, но имеет лучшую числовую стабильность.

использовать:Стабильный вывод и обучение на графических процессорах с поддержкой BF16, таких как NVIDIA A100, H100.

Как использовать:

model = AutoModelForCausalLM.from_pretrained("model_name", torch_dtype="torch.bfloat16").cuda()

3. Модель количественного определения INT8

Тип файла:Квантованный файл модели Hugging Face INT8.

использовать:Значительно снижает использование памяти с минимальной потерей производительности.

Как хранить модели INT8:

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("model_name", device_map="auto", load_in_8bit=True)
model.save_pretrained("./int8_model")

4. Модель ONNX (открытый формат обмена нейронными сетями).

Тип файла: .onnx

использовать:Межплатформенный вывод графического процессора с поддержкой ONNX Runtime и TensorRT.

Как конвертировать в ONNX:

pip install optimum[onnxruntime]
optimum-cli export onnx --model=model_name ./onnx_model

Пример вывода ONNX:

from onnxruntime import InferenceSession

session = InferenceSession("model.onnx", providers=["CUDAExecutionProvider"])

5. Модель TensorRT

Тип файла: .engine

использовать:Собственный формат NVIDIA для высокопроизводительного вывода, поддерживающий FP16 и INT8.

Метод преобразования в TensorRT:

trtexec --onnx=model.onnx --saveEngine=model.engine --fp16

Пример вывода TensorRT:

import tensorrt as trt

6. Другие форматы, связанные с графическим процессором

Модель TorchScript:Использование PyTorch.ptФормат.

Пример сохранения:

scripted_model = torch.jit.script(model)
scripted_model.save("model.pt")

сравнение форматов

Формат	Расширение файла	Оптимизированное использование	рамка
FP16	.bin	Вывод общего назначения графического процессора	PyTorch, TensorFlow
BF16	.bin	численная стабильность	PyTorch, TensorFlow
INT8	.bin	Недостаток памяти графического процессора	Hugging Face + bitsandbytes
ONNX	.onnx	Кроссплатформенный графический процессор	ONNX Runtime, TensorRT
TensorRT	.engine	NVIDIA GPU	TensorRT

GGML

концепция

GGML (Общий уровень графической модели) — это формат модели машинного обучения, разработанный для сценариев с высокой производительностью и низким уровнем ресурсов. Его основная цель — добиться эффективного хранения и вывода моделей, особенно подходящих для устройств с ограниченной памятью.

Функции

Эффективное хранение:Используйте методы квантования для сжатия размера модели и уменьшения требований к памяти.
Быстрое рассуждение:Оптимизированная производительность вывода на нескольких аппаратных архитектурах, подходящая для центральных и графических процессоров.
Кроссплатформенная поддержка:Доступно для настольных, мобильных и встроенных устройств.

использовать

Развертывайте большие языковые модели (например, LLaMA) на устройствах с ограниченными ресурсами.
Ускорьте вывод моделей для приложений реального времени.
Храните и делитесь квантованными моделями машинного обучения.

Инструменты и библиотеки

llama.cpp：Для запуска моделей LLaMA в формате GGML на ЦП.
GPT4All：Поддерживает несколько моделей в формате GGML для автономного вывода.
quantize-tools：Инструменты для преобразования моделей в формат GGML и их квантования.

Преобразование модели

Шаги по преобразованию модели машинного обучения в формат GGML:

Загрузите исходный архив модели (например, в формате PyTorch).pytorch_model.bin）。
Преобразование с использованием инструментов квантования, например.llama.cppСкрипт конвертации предоставлен.
Создавайте архивы моделей в формате GGML, например.model.ggml.q4_0.bin。

Преимущества

Включите вывод больших моделей на устройствах с ограниченным объемом памяти.
Уменьшите размер модели за счет квантования без существенного влияния на производительность.
Улучшена переносимость модели и гибкость развертывания.

Модель ламы

1. Что такое модель Ламы?

Лама (большая языковая модель Meta AI) — это большая языковая модель, разработанная Meta и предназначенная для генерации текста на естественном языке, ответов на вопросы и выполнения задач по пониманию языка.

Эти модели известны своей эффективностью, обеспечивая высококачественные результаты генерации текста при относительно небольшом объеме аппаратных ресурсов.

2. Сценарии применения Ламы

Генерация естественного языка:Используется для создания историй, статей или бесед.

Система вопросов и ответов:Поддерживайте запросы пользователей и генерируйте точные ответы.

Языковой перевод:Поддерживает задачи перевода между несколькими языками.

Понимание языка:Подходит для таких задач, как подведение итогов и анализ настроений.

3. Характеристики ламы

Высокая эффективность:Ламе требуется меньше ресурсов для обучения, чем другим крупным моделям.

Открытость:Meta обеспечивает поддержку исследований и коммерческих приложений и способствует развитию сообщества.

гибкость:Модели могут работать на различных аппаратных платформах, включая центральные и графические процессоры.

4. Как использовать модель Ламы

1. Установите необходимые инструменты:

pip install transformers
pip install sentencepiece

2. Загрузите модель:

из импорта трансформеров AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("мета-лама/Лама-2-7b")
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b").cuda()

input_text = "Что такое лама?"
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.cuda()

вывод = model.generate(input_ids, max_length=50)
печать(tokenizer.decode(выход[0]))

5. Версия модели

Llama предоставляет несколько версий, основная разница заключается в количестве параметров модели (например, 7B, 13B, 70B):

7B：Подходит для легких приложений с минимальными требованиями к ресурсам.
13B：Обеспечивает более высокое качество генерации текста при умеренных требованиях к ресурсам.
70B：Обеспечивает наилучшую производительность, но требует более высоких вычислительных ресурсов.

6. Использование на процессоре и графическом процессоре.

CPU：Формат GGUF можно использовать для эффективного вывода.

GPU：Поддерживает формат FP16 или BF16 для повышения производительности.

7. Оптимизация модели и количественная оценка

Количественная оценка FP16:Уменьшите использование памяти и увеличьте скорость вывода.

Квантование INT8:Подходит для устройств с ограниченными ресурсами для уменьшения потерь производительности.

Модель Мистраль

1. Что такое Мистраль?

Mistral — это крупномасштабная языковая модель, разработанная Mistral AI, которая фокусируется на обеспечении эффективных и точных возможностей обработки естественного языка.

Модель известна своей высокооптимизированной архитектурой и оптимизированными требованиями к вычислительным ресурсам, что делает ее подходящей для различных задач по созданию и пониманию языка.

2. Особенности Мистраля

Эффективность:Mistral разработан с использованием новейшей архитектуры Transformer, обеспечивающей быстрые и точные возможности рассуждения.

Открытость:Модель Mistral имеет открытый исходный код, что позволяет пользователям запускать ее локально и настраивать.

Масштабируемость:Модель поддерживает несколько форматов квантования и подходит для различных аппаратных сред.

Защита конфиденциальности:Может быть развернут в локальной среде, чтобы избежать риска утечки данных.

3. Сценарии применения Мистраля

Генерация контента:Включая написание статей, генерацию бесед и копирайтинг.

Понимание языка:Используется для таких задач, как классификация текста и анализ настроений.

Образовательные приложения:Оказывать помощь в обучении и отвечать на академические вопросы.

Система автоматизации:Интегрируйтесь в системы обслуживания клиентов или другие автоматизированные процессы.

4. Как пользоваться моделью Мистраль

1. Установите зависимости:

pip install transformers

2. Загрузите модель:Загрузите архивы моделей Mistral с Hugging Face или других официальных источников.

3. Загрузите модель:

из импорта трансформеров AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("мистралай/Мистраль-7Б")
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B").cuda()

input_text = "Что такое Мистраль?"
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.cuda()

вывод = model.generate(input_ids, max_length=50)
печать(tokenizer.decode(выход[0]))

5. Поддерживаемая аппаратная архитектура.

CPU：Поддерживает высокопроизводительный вывод ЦП и может быть оптимизирован с использованием формата GGUF.

GPU：Поддерживает форматы FP16 или BF16 для оптимальной производительности на графических процессорах NVIDIA.

6. Версия модели

Мистраль выпускается в нескольких модификациях, основные отличия заключаются в количестве параметров и характеристиках:

7B：Подходит для повседневных приложений, обеспечивая баланс между производительностью и требованиями к ресурсам.
Большие модели:Для более точного профессионального применения.

7. Оптимизация и количественная оценка

Формат количественного определения:Используйте формат INT8 или GGUF, чтобы уменьшить требования к памяти и повысить эффективность вывода.

Оптимизация производительности:Используйте аппаратные функции, такие как набор инструкций AVX или ускорение CUDA, для эффективных вычислений.

модель Джеммы

1. Что такое Джемма?

Gemma — это крупномасштабная языковая модель с открытым исходным кодом, предназначенная для эффективных задач обработки естественного языка.

Благодаря своей универсальности и масштабируемости, модель поддерживает генерацию текста, понимание языка и задачи перевода на несколько языков.

2. Особенности Джеммы

Многоязычная поддержка:Gemma может работать с несколькими языками, что делает ее подходящей для глобальных сценариев применения.

Легкий:Модель хорошо оптимизирована для оборудования с ограниченными ресурсами.

Масштабируемость:Поддерживает работу в нескольких аппаратных средах, включая процессор и графический процессор.

Открытый исходный код:Открытый исходный код позволяет пользователям выполнять вторичную разработку и настройку.

3. Сценарии применения Gemma

Генерация естественного языка:Подходит для создания контента, написания статей и создания бесед.

Понимание языка:Включая такие задачи, как анализ настроений, классификация тем и обобщение текста.

Машинный перевод:Предоставляйте высокоточные услуги многоязычного перевода.

Образование и исследования:В качестве учебного пособия или платформы для анализа исследований.

4. Как использовать модель Джеммы

1. Установите зависимости:

pip install gemma

2. Загрузите модель:Загрузите соответствующий файл модели Gemma с официального сайта или из библиотеки моделей.

3. Загрузите модель:

из импорта Gemma GemmaModel, GemmaTokenizer

#Инициализируем токенизатор и модель
tokenizer = GemmaTokenizer.from_pretrained("gemma-ai/gemma-base")
model = GemmaModel.from_pretrained("gemma-ai/gemma-base").cuda()

# Подготовьтесь к вводу текста
input_text = "Что такое Джемма?"
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.cuda()

# Генерируем вывод
выходные данные = model.generate(input_ids, max_length=50)
печать(tokenizer.decode(выходы[0]))

5. Версия модели

Gemma предлагает несколько версий для удовлетворения различных потребностей:

Базовая версия:Обеспечивает базовую производительность для повседневного использования.
Про версия:Обеспечивает более высокую точность и больший объем параметров, подходящий для нужд высокого класса.
Облегченная версия:Оптимизируйте для устройств с ограниченными ресурсами.

6. Поддерживаемая аппаратная архитектура

CPU：Поддерживает вывод ЦП и подходит для сред с низким уровнем ресурсов.

GPU：Работает на графических процессорах с поддержкой CUDA для обеспечения высокой производительности.

7. Оптимизация и количественная оценка

Количественные методы:Поддерживает форматы INT8 и FP16, сокращая использование памяти при сохранении стабильной производительности.

Аппаратная оптимизация:Используйте аппаратные функции, такие как набор инструкций AVX, для дальнейшего ускорения вывода.

GPT4All

1. Что такое GPT4All?

GPT4All — это крупномасштабная языковая модель с открытым исходным кодом, предназначенная для обработки естественного языка на локальных устройствах без облачных зависимостей.

Эта модель обеспечивает эффективные возможности генерации текста, подходит для сценариев многоязычных приложений и предназначена для оборудования с низким уровнем ресурсов.

2. Особенности GPT4All

Открытый исходный код:GPT4All имеет полностью открытый исходный код и может быть настроен в соответствии с вашими потребностями.

Запустить локально:Поддерживает работу на ПК, ноутбуке или сервере, подключение к сети не требуется.

Легкий:Может работать на процессоре и графическом процессоре с низкими характеристиками, что снижает требования к оборудованию.

Защита конфиденциальности:Поскольку все операции выполняются локально, данные пользователя не попадают на внешние серверы.

3. Сценарии применения GPT4All

Создание контента:Используйте его для написания статей, рассказов, блогов или технических документов.

Система вопросов и ответов:Создайте помощника по вопросам и ответам, который работает в автономном режиме.

Образовательная помощь:Действует как инструмент обучения и решения проблем, помогая пользователям понять сложные концепции.

Помощь развитию:Используется для генерации кода или предоставления предложений по разработке программы.

4. Как скачать и использовать GPT4All

1. Установите зависимости:

pip install gpt4all

2. Загрузите файл модели:Загрузите необходимый архив модели с официального сайта GPT4All (например,.binили.ggufФормат).

3. Загрузите модель:

из gpt4all импортировать GPT4All

модель = GPT4All("gpt4all-lora-quantized.bin")
ответ = model.generate("Привет, что такое GPT4All?", max_tokens=100)
распечатать (ответ)

5. Поддерживаемые форматы файлов

.bin：Общий формат квантовой модели, подходящий для большинства устройств.

.gguf：Формат, оптимизированный для ЦП, подходящий для эффективного вывода на устройствах с низким уровнем ресурсов.

6. Запуск на процессоре и графическом процессоре

CPU：GPT4All поддерживает высокопроизводительный вывод ЦП и подходит для сред без графических процессоров.

GPU：Если у вас есть графический процессор NVIDIA, вы можете использовать PyTorch или другие платформы для ускорения.

7. Оптимизация и количественная оценка

Количественная модель:Используйте INT8 или другие методы квантования, чтобы уменьшить использование памяти.

Оптимизация производительности:Используйте аппаратные функции, такие как набор инструкций AVX, для ускорения вывода.

GPT4Все основные характеристики графического процессора

Вам нужен факел или тензорный поток?

ненужный. GPT4All вообще не полагается на факел (PyTorch) или тензорный поток.

Ядро вывода — C/C++ (на основе llama.cpp).
Непосредственная загрузка моделей .gguf
Не знаю, как использовать среду глубокого обучения Python

GPT4All Фактическая архитектура пакета Python

Python GPT4Все
  ↓
Серверная часть C++ (версия ЦП llama.cpp)
  ↓
модель .gguf

.gguf расположение загрузки модели по умолчанию

Если передается только имя файла модели, оно будет автоматически загружено в папку кэша в домашнем каталоге пользователя:

~/.cache/gpt4all/

Windows: C:\Users\users\.cache\gpt4all\
Linux: /home/users/.cache/gpt4all/
macOS:/Users/users/.cache/gpt4all/

Укажите каталог модели

from gpt4all import GPT4All

model = GPT4All(
    "Meta-Llama-3-8B-Instruct.Q4_0.gguf",
    model_path="D:/llm_models/gpt4all"
)

Поддерживать ли графический процессор

Не поддерживается. API Python GPT4All в настоящее время предназначен только для процессора.

Невозможно использовать CUDA, Metal или Vulkan.
Параметр n_gpu_layers не существует
Даже если есть графический процессор, будет использоваться только процессор.

причина ошибки n_gpu_layers

Возникает следующая ошибка:

TypeError: GPT4All.__init__() got an unexpected keyword argument 'n_gpu_layers'

Это означает, что установленная в данный момент привязка GPT4All Python не реализует параметры, связанные с графическим процессором, что является нормальным поведением.

Почему GPT4All Desktop может использовать графический процессор

Рабочий стол использует автономный скомпилированный файл llama.cpp (с CUDA/Metal).
Пакет Python — это просто упрощенный пакет с меньшим количеством функций.
Способности этих двоих не равны

Действительно полезная альтернатива графическому процессору

Ollama

import ollama

response = ollama.chat(
    model="llama3:8b-instruct",
    messages=[
        {"role": "user", "content": "Explain CUDA in one sentence"}
    ]
)

print(response["message"]["content"])

характеристика:

Не требуется горелка или тензорный поток
Автоматически использовать графический процессор
Самый простой в установке и использовании

llama-cpp-python

from llama_cpp import Llama

llm = Llama(
    model_path="Meta-Llama-3-8B-Instruct.Q4_0.gguf",
    n_gpu_layers=999,
    n_ctx=4096
)

print(llm("Explain CUDA in one sentence")["choices"][0]["text"])

характеристика:

Не требуется горелка или тензорный поток
Полная поддержка слоев графического процессора
Полностью совместим с моделями .gguf.

Концепция разницы в производительности

GPT4All Python CPU: от ~1 до 2 токенов в секунду.
Графический процессор (RTX 3060): от ~ 12 до 18 токенов в секунду
Графический процессор (RTX 4090): может превышать 35 токенов в секунду.

в заключение

GPT4All не требует факела или тензорного потока.
GPT4All Python может использовать только процессор
Для вывода графического процессора вместо этого вы должны использовать Ollama или llama-cpp-python.
Модели .gguf можно использовать повторно без повторной загрузки.

Использование мощности удаленного графического процессора Python

Удаленная разработка SSH и Jupyter

Это наиболее распространенный и интуитивно понятный метод, подходящий для разработчиков, у которых есть стационарные удаленные серверы (например, хосты компании или лаборатории).

Переадресация портов SSH:Выдайте команду на локальной стороне, чтобы сопоставить порт 8888 удаленного сервера с локальной стороной, и вы сможете управлять удаленным сервером в локальном браузере.Jupyter Notebookи вызовите графический процессор машины.
VS Code Remote - SSH：Подключайтесь напрямую к удаленным средам с помощью расширений VS Code. Опыт разработки такой же, как и локальная разработка. Все сценарии Python будут выполняться непосредственно в удаленной среде графического процессора, а переменные и выходные данные можно будет просмотреть в режиме реального времени.

Распределенная вычислительная среда

Когда один графический процессор не может удовлетворить спрос или задачи необходимо динамически назначать разным узлам, можно использовать выделенную распределенную платформу.

Ray：Ray — это текущая распространенная распределенная архитектура Python, которая может преобразовывать функции Python в удаленные задачи. Он может автоматически управлять ресурсами графического процессора в кластере, позволяя разработчикам выполнять операции с графическими процессорами разных машин с помощью простых декораторов.
Платформа PyTorch RPC:Встроенная функция удаленного вызова процедур PyTorch позволяет программе на узле A вызывать ресурсы графического процессора узла B для обучения модели или вывода, что подходит для сложных архитектур моделей.

Платформа облачных вычислений и развертывание контейнеров

Если у разработчиков нет собственного аппаратного оборудования, они могут воспользоваться ресурсами облачного графического процессора по требованию.

план	Выполнение
интерактивная платформа	Используйте Google Colab или Kaggle Kernels, чтобы напрямую получать бесплатные или платные удаленные графические процессоры (например, T4, A100) через браузер.
Услуга аренды вычислительной мощности	Арендуйте определенные контейнеры графического процессора через RunPod или Lambda Labs и используйте образы Docker для быстрого развертывания сред выполнения Python.
Корпоративный API	Используйте AWS SageMaker или GCP Vertex AI, чтобы инкапсулировать сценарии Python в задания и отправлять их в облако для выполнения. Система автоматически выделит ресурсы графического процессора и перезапустит их после завершения операции.

Оптимизация передачи данных

При использовании удаленных вычислительных мощностей узким местом часто является передача данных по сети, а не сами вычисления. Рекомендуются следующие стратегии:

Оптимизация сериализации:Используйте Apache Arrow или Pickle для эффективной сериализации данных.
Асинхронная передача:Убедитесь, что загрузка данных и операции графического процессора синхронизированы, чтобы графический процессор не простаивал в ожидании данных.

Python Ray

Единая платформа для распределенных вычислений

RayЭто среда распределенных вычислений с открытым исходным кодом, предназначенная для того, чтобы приложения Python могли легко масштабироваться от одной машины до большого кластера. Он решает проблему ограниченной производительности одного процессора в Python при работе с крупномасштабным машинным обучением, обработкой данных и выводом в реальном времени.

основной вычислительный блок

Рэй преобразует стандартный код Python в распределенные задачи с помощью простых декораторов:

Задачи:через@ray.remoteОпределенная асинхронная функция. Они не сохраняют состояние и идеально подходят для параллельной обработки независимых вычислительных задач.
Актеры:через@ray.remoteопределенные категории. Они сохраняют состояние и могут сохранять данные между несколькими задачами, что делает их пригодными для использования в средах моделирования или обслуживания моделей.
Объекты:Рэй использует распределенную общую память для хранения результатов вычислений, избегая накладных расходов, связанных с частым копированием больших данных между разными узлами.

Реализация планирования ресурсов графического процессора

Для разработчиков, которым нужна мощная вычислительная мощность, Ray предлагает чрезвычайно простой метод планирования графического процессора. Вам не нужно вручную управлять количеством устройств CUDA, просто укажите требования к ресурсам при определении удаленной задачи:

@ray.remote(num_gpus=1)
защита train_model (данные):
    # Рэй автоматически назначит эту задачу узлам с простаивающими графическими процессорами
    # И установите переменную среды CUDA_VISIBLE_DEVICES
    вернуть «Обучение завершено»

Эта абстракция позволяет разработчикам сосредоточиться на логике алгоритма, не беспокоясь о распределении и повторном использовании базовых аппаратных ресурсов.

экосистемные библиотеки

Ray — это больше, чем просто механизм выполнения, он также включает в себя ряд библиотек, оптимизированных для рабочих процессов ИИ:

название библиотеки	Основные функции
Ray Data	Загрузка и преобразование данных для крупномасштабного обучения машинному обучению с поддержкой потоковой обработки.
Ray Train	Упростите обучение распределенных моделей (поддерживает PyTorch, TensorFlow, Horovod и т. д.).
Ray Tune	Платформа эффективной оптимизации гиперпараметров (Hyperparameter Tuning).
Ray Serve	Используется для развертывания моделей машинного обучения с функциями автоматического расширения и балансировки нагрузки.

Почему стоит выбрать Рэя

Самая большая ценность Рэя заключается в егонизкая задержкаиВысокая пропускная способностьхарактеристики. По сравнению с традиционными очередями задач (такими как Celery) или тяжелыми распределенными платформами (такими как Spark), синтаксис Ray ближе к собственному стилю Python, а его механизм планирования динамических графов может обрабатывать чрезвычайно сложные и зависимые вычислительные задачи.

PyTorch RPC

Децентрализованная система обучения

PyTorch RPC (Remote Procedure Call)Это среда распределенного обучения, официально предоставляемая PyTorch, предназначенная для поддержки сложных моделей, которые невозможно легко обработать с помощью параллелизма данных (параллелизм данных). Это позволяет узлу (работнику) вызывать функцию на другом удаленном узле и получать результат или ссылаться на удаленный объект как на локальную функцию.

Ключевые понятия

Агент РПК:Отвечает за управление сетевыми подключениями, сериализацию данных и передачу сообщений между различными узлами. В настоящее время в основном используетсяTensorPipeВ качестве бэкенда, оптимизированного для передачи тензоров.
Дистанционное задание (RRef):Полное название — Remote Reference. Это дескриптор (Handle), указывающий на объект на удаленном узле. С помощью RRef вы можете манипулировать тензорами или параметрами модели между узлами, не перемещая весь объект по сети.
Распространённый Автоград:Это одна из основных особенностей инфраструктуры RPC. Он может автоматически отслеживать график операций на разных узлах и координировать все участвующие узлы для выполнения вычислений градиента при выполнении обратного распространения ошибки.
Распределенный оптимизатор:Вместе с RRef и распределенным автоматическим выводом разработчики могут одновременно обновлять параметры модели, распределенные на разных машинах, точно так же, как при использовании локального оптимизатора.

Основной метод вызова

имя метода	Характеристики исполнения
`rpc_sync`	синхронный вызов. После отправки запроса текущий поток выполнения будет заблокирован до тех пор, пока не будет получен результат ответа от удаленного конца.
`rpc_async`	асинхронный вызов. Отправьте один обратно немедленно`Future`Объект, программа может продолжать выполнять другие задачи и получать результаты позже.
`remote`	Удаленное учреждение. Создайте объект на удаленном узле и верните`RRef`, подходит для создания удаленного сервера параметров (Parameter Server).

Сценарии применения

PyTorch RPC особенно подходит для следующих типов очень сложных распределенных задач:

Распределенная параллельная модель:Если модель слишком велика для размещения на одном графическом процессоре, ее можно разделить на несколько машин для выполнения на нескольких графических процессорах.
Архитектура сервера параметров (сервер параметров):Выделенные узлы хранят параметры, а несколько обучающих узлов считывают и обновляют параметры через RPC.
Обучение с подкреплением:Несколько агентов выборки (Агенты) выполняют среду удаленно и возвращают опыт централизованному учащемуся (Обучающемуся) через RPC.

технические проблемы

При использовании инфраструктуры RPC разработчикам приходится сталкиваться с более серьезными трудностями при отладке, чем при общем обучении. Поскольку задействована межмашинная связь, задержка сети и пропускная способность часто становятся узкими местами производительности. Кроме того, управление жизненным циклом объектов (посредством подсчета ссылок RRef) также более сложно в распределенной среде, и необходимо гарантировать, что удаленные объекты могут быть правильно переработаны, когда они больше не нужны.

email: [email protected]

T:0000

資訊與搜尋 | 回dev首頁 | 回ai首頁
email: Yan Sa [email protected] Line: 阿央

電話: 02-27566655 ,03-5924828

阿央
泱泱科技
捷昱科技泱泱企業

категория	Часто используемые слои (tf.keras.layers)	Основные функции
Базовый слой (ядро)	`Dense`	Полносвязный слой, выполните \(y = f(Wx + b)\).
Сверточный слой	`Conv2D`, `Conv1D`	Используется для извлечения признаков, часто используется в изображениях или временных рядах.
Слой объединения (Pooling)	`MaxPooling2D`, `AveragePooling2D`	Уменьшите размерность и сократите объем вычислений, сохранив при этом ключевые функции.
Рекуррентный слой (Рекуррентный)	`LSTM`, `GRU`, `SimpleRNN`	Обрабатывает последовательность данных (например, текст, цены на акции) и имеет память.
Уровень регуляризации (Регуляризация)	`Dropout`, `BatchNormalization`	Предотвратите переоснащение и ускорьте конвергенцию.

中文

DE

EN

JA

KO

развитие искусственного интеллекта

ИИ-приложение

разработка программного обеспечения

Инвестиционно-программное обеспечение

Python

алгоритм глубокого обучения

1. Нейронная сеть прямого распространения (FNN).

2. Сверточная нейронная сеть (CNN).

3. Рекуррентная нейронная сеть (RNN).

Длинная краткосрочная память (LSTM)

4. Автоэнкодер

5. Генеративно-состязательная сеть (GAN)

6. Transformer

Платформа машинного обучения TensorFlow

1. Основное определение и структура

2. Основные компоненты и уровни

3. Жизненный цикл разработки модели

4. Основные преимущества и применение

5. Простой пример кода

API глубокого обучения Keras

1. Базовое определение и позиционирование

2. Основная концепция дизайна

3. Три способа построения модели.

4. Стандартный процесс разработки

5. Примеры кода

6. Связь между Keras и TensorFlow

Основные компоненты слоя Keras

1. Основное определение

2. Сравнительная таблица типов основных слоев

3. Описание важных параметров

4. Общие операции и вспомогательные слои

5. Пример реализации кода

6. Расчет весов и параметров

Нейронная сеть прямого распространения Keras

1. Базовое определение FNN

2. Создайте пример модели FNN.

3. Составление и выполнение модели.

4. Таблица сравнения ключевых компонентов FNN

5. Сценарии применения и ограничения

Пример Кераса CNN

1. Описание базовой архитектуры CNN

2. Создайте пример модели CNN.

3. Составление и обучение модели.

4. Сравнительная таблица функций ключевого слоя

5. Рекомендации по отладке и оптимизации производительности.

Рекуррентная нейронная сеть Keras RNN

1. Основные концепции RNN

2. Создайте пример модели RNN.

3. Описание измерения данных

4. Часто используемая сравнительная таблица уровней цикла

5. Рекомендации по обучению и отладке

Прогнозирование временных рядов Keras LSTM

1. Базовая архитектура LSTM

2. Создайте пример модели LSTM.

3. Преобразование измерений данных (изменение формы)

4. Описание основных параметров

5. Рекомендации по отладке

Автоэнкодер Керас

1. Основные понятия автоэнкодеров

2. Создайте простой пример автокодировщика.

3. Сравнительная таблица распространенных сценариев применения

4. Глубокие сверточные автоэнкодеры (CAE).

5. Обучение и мониторинг эффективности

Keras генерирует враждебные сети

1. Основной рабочий механизм GAN

2. Установите компоненты модели GAN.

3. Сравнительная таблица тренировочного процесса

4. Глубокий сверточный ГАН (DCGAN)

5. Трудности в обучении и предложения

Модель трансформатора Керас

1. Механизм сердечника трансформатора

2. Создайте блок-трансформер.

3. Пример полной модели классификации

4. Сравнительная таблица ключевых компонентов

5. Рекомендации по обучению и отладке