Глибоке навчання на практиці

Глибоке навчання перейшло від теоретичної концепції до потужного інструменту, який змінює світ. У цій статті ми розглянемо практичні аспекти глибокого навчання та побачимо, як можна застосувати ці технології для вирішення реальних задач.

Налаштування середовища для глибокого навчання

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

1. Вибір фреймворку

Для роботи з глибоким навчанням можна використовувати різні фреймворки:

TensorFlow — фреймворк від Google з великою спільнотою та багатьма готовими моделями
PyTorch — фреймворк від Facebook, який відрізняється динамічним обчислювальним графом
Keras — високорівневий API, який працює поверх TensorFlow

У нашому прикладі ми будемо використовувати TensorFlow з Keras API, оскільки це один з найпопулярніших варіантів для початківців.

2. Установка необхідного програмного забезпечення

                    
                    # Установка TensorFlow та Keras

                    pip install tensorflow

                    # Інші корисні бібліотеки

                    pip install numpy pandas matplotlib scikit-learn

3. Вибір апаратного забезпечення

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

GPU (графічний процесор) — значно прискорює навчання моделей
Достатній обсяг оперативної пам'яті (мінімум 8 ГБ, рекомендовано 16+ ГБ)

Якщо у вас немає доступу до потужного обладнання, можна використовувати хмарні сервіси, такі як Google Colab, AWS або Microsoft Azure.

Робоче середовище для глибокого навчання

Типове середовище для розробки моделей глибокого навчання включає Python, фреймворк та GPU

Практичний приклад: Класифікація зображень

Розглянемо практичний приклад використання глибокого навчання для класифікації зображень. Ми створимо модель, яка може розпізнавати 10 різних категорій об'єктів на зображеннях.

Крок 1: Підготовка даних

Спочатку завантажимо набір даних CIFAR-10, який містить 60000 кольорових зображень розміром 32x32 пікселів в 10 категоріях.

                    
                    import tensorflow as tf

                    from tensorflow.keras.datasets import cifar10

                    from tensorflow.keras.utils import to_categorical

                    # Завантаження даних

                    (x_train, y_train), (x_test, y_test) = cifar10.load_data()

                    # Нормалізація даних

                    x_train = x_train.astype('float32') / 255.0

                    x_test = x_test.astype('float32') / 255.0

                    # Перетворення міток у one-hot encoding

                    y_train = to_categorical(y_train, 10)

                    y_test = to_categorical(y_test, 10)

Крок 2: Створення моделі

Тепер створимо згорткову нейронну мережу (CNN) для класифікації зображень:

                    
                    from tensorflow.keras.models import Sequential

                    from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

                    model = Sequential([

                        # Перший згортковий блок

                        Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)),

                        Conv2D(32, (3, 3), activation='relu', padding='same'),

                        MaxPooling2D((2, 2)),

                        Dropout(0.25),

                        # Другий згортковий блок

                        Conv2D(64, (3, 3), activation='relu', padding='same'),

                        Conv2D(64, (3, 3), activation='relu', padding='same'),

                        MaxPooling2D((2, 2)),

                        Dropout(0.25),

                        # Повнозв'язані шари

                        Flatten(),

                        Dense(512, activation='relu'),

                        Dropout(0.5),

                        Dense(10, activation='softmax')

                    ])

Крок 3: Компіляція моделі

Визначимо функцію втрат, оптимізатор та метрики для оцінки продуктивності моделі:

                    
                    model.compile(

                        loss='categorical_crossentropy',

                        optimizer='adam',

                        metrics=['accuracy']

                    )

Крок 4: Навчання моделі

Тепер навчимо нашу модель на тренувальних даних:

                    
                    from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

                    # Callbacks для збереження найкращої моделі та раннього зупинення

                    checkpoint = ModelCheckpoint('best_model.h5', save_best_only=True, monitor='val_accuracy')

                    early_stopping = EarlyStopping(patience=10, restore_best_weights=True)

                    # Навчання моделі

                    history = model.fit(

                        x_train, y_train,

                        batch_size=64,

                        epochs=50,

                        validation_split=0.2,

                        callbacks=[checkpoint, early_stopping]

                    )

Крок 5: Оцінка моделі

Оцінимо продуктивність нашої моделі на тестових даних:

                    
                    # Оцінка на тестових даних

                    test_loss, test_acc = model.evaluate(x_test, y_test)

                    print(f'Точність на тестових даних: {test_acc:.4f}')

Крок 6: Візуалізація результатів

Нарешті, візуалізуємо результати навчання та деякі приклади прогнозів:

                    
                    import matplotlib.pyplot as plt

                    import numpy as np

                    # Візуалізація графіків точності та втрат

                    plt.figure(figsize=(12, 5))

                    plt.subplot(1, 2, 1)

                    plt.plot(history.history['accuracy'], label='Тренувальна точність')

                    plt.plot(history.history['val_accuracy'], label='Валідаційна точність')

                    plt.xlabel('Епоха')

                    plt.ylabel('Точність')

                    plt.legend()

                    plt.subplot(1, 2, 2)

                    plt.plot(history.history['loss'], label='Тренувальна втрата')

                    plt.plot(history.history['val_loss'], label='Валідаційна втрата')

                    plt.xlabel('Епоха')

                    plt.ylabel('Втрата')

                    plt.legend()

                    plt.tight_layout()

                    plt.show()

Поліпшення моделі та техніки оптимізації

Після створення базової моделі можна застосувати різні техніки для поліпшення її продуктивності:

1. Аугментація даних

Збільшення різноманітності тренувальних даних шляхом застосування випадкових трансформацій (повороти, масштабування, зсуви) до існуючих зображень:

                    
                    from tensorflow.keras.preprocessing.image import ImageDataGenerator

                    datagen = ImageDataGenerator(

                        rotation_range=15,

                        width_shift_range=0.1,

                        height_shift_range=0.1,

                        horizontal_flip=True,

                        zoom_range=0.1

                    )

                    datagen.fit(x_train)

2. Трансферне навчання

Використання попередньо навченої моделі як основи для нашої задачі:

                    
                    from tensorflow.keras.applications import ResNet50

                    from tensorflow.keras.models import Model

                    # Завантаження попередньо навченої моделі

                    base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

                    # Заморожування шарів базової моделі

                    for layer in base_model.layers:

                        layer.trainable = False

                    # Додавання наших шарів

                    x = base_model.output

                    x = GlobalAveragePooling2D()(x)

                    x = Dense(1024, activation='relu')(x)

                    predictions = Dense(10, activation='softmax')(x)

                    # Створення нової моделі

                    model = Model(inputs=base_model.input, outputs=predictions)

3. Регуляризація

Запобігання перенавчанню за допомогою різних методів регуляризації:

Dropout — випадкове вимкнення нейронів під час навчання
L1/L2 регуляризація — додавання штрафів за великі ваги
Batch Normalization — нормалізація активацій для стабілізації навчання

4. Налаштування гіперпараметрів

Пошук оптимальних гіперпараметрів за допомогою Grid Search або Random Search:

                    
                    from sklearn.model_selection import RandomizedSearchCV

                    from tensorflow.keras.wrappers.scikit_learn import KerasClassifier

                    # Функція для створення моделі з різними гіперпараметрами

                    def create_model(learning_rate=0.001, dropout_rate=0.5, units=512):

                        # Код створення моделі...

                        return model

                    # Створення обгортки KerasClassifier

                    model = KerasClassifier(build_fn=create_model, verbose=0)

                    # Визначення простору пошуку

                    param_dist = {

                        'learning_rate': [0.0001, 0.001, 0.01],

                        'dropout_rate': [0.3, 0.4, 0.5],

                        'units': [256, 512, 1024],

                        'batch_size': [32, 64, 128],

                        'epochs': [30, 50]

                    }

                    # Випадковий пошук

                    random_search = RandomizedSearchCV(

                        model, param_dist, n_iter=10, cv=3, n_jobs=-1

                    )

                    random_search.fit(x_train, y_train)

Розгортання моделі глибокого навчання

Після навчання та оптимізації моделі важливо зробити її доступною для використання. Ось кілька способів розгортання моделей глибокого навчання:

1. Збереження та завантаження моделі

                    
                    # Збереження моделі

                    model.save('my_model.h5')

                    # Завантаження моделі

                    from tensorflow.keras.models import load_model

                    loaded_model = load_model('my_model.h5')

2. Конвертація моделі для мобільних пристроїв

                    
                    import tensorflow as tf

                    # Конвертація в TensorFlow Lite

                    converter = tf.lite.TFLiteConverter.from_keras_model(model)

                    tflite_model = converter.convert()

                    # Збереження TensorFlow Lite моделі

                    with open('model.tflite', 'wb') as f:

                        f.write(tflite_model)

3. Створення API за допомогою Flask

                    
                    from flask import Flask, request, jsonify

                    import numpy as np

                    from tensorflow.keras.models import load_model

                    from PIL import Image

                    import io

                    app = Flask(__name__)

                    model = load_model('my_model.h5')

                    @app.route('/predict', methods=['POST'])

                    def predict():

                        # Отримання зображення з запиту

                        file = request.files['image']

                        img = Image.open(io.BytesIO(file.read()))

                        img = img.resize((32, 32))

                        img_array = np.array(img) / 255.0

                        img_array = np.expand_dims(img_array, axis=0)

                        # Отримання прогнозу

                        predictions = model.predict(img_array)

                        predicted_class = np.argmax(predictions, axis=1)[0]

                        return jsonify({'class': int(predicted_class)})

                    if __name__ == '__main__':

                        app.run(debug=True)

4. Розгортання в хмарі

Можна розгорнути модель у хмарних сервісах, таких як:

AWS SageMaker
Google AI Platform
Microsoft Azure Machine Learning
TensorFlow Serving

Підсумок

У цій статті ми розглянули практичні аспекти глибокого навчання, починаючи від налаштування середовища і закінчуючи розгортанням моделі. Ми створили модель для класифікації зображень, використовуючи згорткову нейронну мережу, та розглянули різні способи поліпшення її продуктивності. Пам'ятайте, що глибоке навчання — це ітеративний процес, який вимагає експериментів і налаштувань для досягнення найкращих результатів.