Julia в машинном обучение: база

Привет, Хабр!

Julia зародилась в 2012 году, благодаря усилиям четырех энтузиастов-разработчиков: Джефф Безансон, Стефан Карпински, Вирал Би Шах, и Алан Эдельман. Они стремились создать язык, который сочетал бы легкость Python, скорость C, динамичность Ruby, лингвистическую чистоту Lisp и возможности математических систем вроде Matlab. Им удалось! Julia – это слияние простоты и мощи.

Благодаря function add(a, b) return a + b end println(add(10, 20)) # вывод: 30 println(add(10.5, 20.3)) # вывод: 30.8

add функция может принимать любые типы, которые поддерживают операцию сложения.

function add(a::Int, b::Int)     return a + b end  println(add(10, 20))  # вывод: 30 println(add(10.5, 20.3))  # вызовет ошибку, так как аргументы не являются Int 

add строго ограничена целочисленными аргументами.

function add{T <: Number}(a::T, b::T)     return a + b end  println(add(10, 20))  # вывод: 30 println(add(10.5, 20.3))  # вывод: 30.8

add принимает аргументы одного типа, но этот тип может быть любым подтипом Number.

Многопоточность

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

Базовая многопоточность выглядит так:

using Base.Threads  function threaded_sum(arr)     nthreads = nthreads()  # получаем количество потоков     sums = zeros(nthreads)  # массив для сумм по каждому потоку     @threads for i in 1:nthreads         # Распределяем итерации цикла по потокам         for j in i:nthreads:length(arr)             sums[i] += arr[j]         end     end     return sum(sums)  # суммируем результаты всех потоков end  arr = rand(1:100, 10^6)  # большой массив случайных чисел println(threaded_sum(arr))  # использование многопоточности для подсчета суммы

С атомарными операциями:

using Base.Threads  function threaded_increment(n)     count = Atomic{Int64}(0)  # атомарная переменная     @threads for i in 1:n         atomic_add!(count, 1)  # безопасное увеличение счетчика     end     return count[] end  println(threaded_increment(10^6))  # увеличиваем счетчик многократно в многопоточном режиме 

Библиотеки для ML

Для julia на гите есть юпитер.

Flux.jl

Flux.jl — это самая основная и базированная библиотека в машинном обучение для джулии.

Flux предоставляет множество предопределенных слоев, которые являются строительными блоками для нейронных сетей.

Dense layer: основной слой для создания полносвязных сетей:

dense = Dense(10, 5, σ)  # 10 входов, 5 выходов, сигмоидная функция активации

Convolutional layer: для создания сверточных сетей:

conv = Conv((3, 3), 1=>16, σ)  # 3x3 фильтры, 1 входной канал, 16 выходных каналов

Flux имеет функции активации, такие как σ, relu, tanh:

relu_layer = Dense(10, 5, relu)

Оптимизаторы используются для обновления весов модели в процессе обучения. Flux поддерживает различные оптимизаторы, такие как SGD, Adam, RMSprop:

Пример с SGD:

opt = Descent(0.01)  # SGD с шагом обучения 0.01

Функции потерь как кросс-энтропия или MSE используются для оценки производительности модели, к примеру кросс-энтропия может выглядеть так:

loss(x, y) = Flux.Losses.crossentropy(model(x), y)

Flux предоставляет утилиты для упрощения процесса обучения, такие как train!:

data = [(x, y), ...]  # набор данных Flux.train!(loss, params(model), data, opt)

Создадим простую полносвязную нейронную сеть для классификации изображений из набора данных MNIST:

using Flux, Flux.Data.MNIST, Statistics using Flux: onehotbatch, onecold, crossentropy, throttle using Base.Iterators: repeated  # так выгдядит загрузка  images = float.(reshape(hcat(float.(MNIST.images())...), 28 * 28, :)) labels = onehotbatch(MNIST.labels(), 0:9)  # делим данные на обучающую тестовую выборку train_indices = 1:60000 x_train, y_train = images[:, train_indices], labels[:, train_indices]  test_indices = 60001:70000 x_test, y_test = images[:, test_indices], labels[:, test_indices]  # объявляем модель model = Chain(   Dense(28*28, 64, relu),   Dense(64, 10),   softmax )  # функция потерь и оптимизатор loss(x, y) = crossentropy(model(x), y) opt = ADAM()  # само обучение dataset = repeated((x_train, y_train), 200) evalcb = () -> @show(loss(x_train, y_train)) Flux.train!(loss, params(model), dataset, opt, cb = throttle(evalcb, 10))

MLJ

MLJ (Machine learning in Julia) предоставляет унифицированный интерфейс для доступа к широкому спектру моделей машинного обучения.

MLJ упрощает процесс загрузки и предварительной обработки данных.

Загрузка данных:

using MLJ X, y = @load_iris

Выглядит весьма интересно.

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

Выбор модели:

tree_model = @load DecisionTreeClassifier

Настройка гиперпараметров:

tree = tree_model(max_depth=5)

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

Обучение модели:

mach = machine(tree, X, y) fit!(mach)

Предсказание:

yhat = predict(mach, Xnew)

Оценки производительности моделей естественно есть в этой библио, к примеру оценка с помощью кросс-энтропии выглядит так:

cv = cross_validation(mach, K=5) cv_measure = mean(cv.measurements)

Применим MLJ для классификации ирисов, используя дерево решений:

using MLJ  # грузим набор X, y = @load_iris  # делим данные на обучающую и тестовую выборки train, test = partition(eachindex(y), 0.7, shuffle=true)  # выбираем модель и настраиваем гиперпараметров tree_model = @load DecisionTreeClassifier tree = tree_model(max_depth=5)  # создаем и обучаем mach = machine(tree, X, y) fit!(mach, rows=train)  # предсказание для тестовой выборки yhat = predict(mach, rows=test)

ScikitLearn.jl:

Для тех, кто привык к Scikit-Learn в питоне, ScikitLearn.jl предлагает похожий опыт, но с Julia.

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

using ScikitLearn @sk_import datasets: load_iris iris = load_iris()

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

@sk_import preprocessing: StandardScaler scaler = StandardScaler() X_scaled = fit_transform(scaler, iris["data"])

Функция для разделения данных на обучающую и тестовую выборку:

@sk_import model_selection: train_test_split X_train, X_test, y_train, y_test = train_test_split(iris["data"], iris["target"], test_size=0.4)

ScikitLearn.jl имеет много алгоритмов, включая линейные модели, деревья решений и т.д:

@sk_import linear_model: LogisticRegression model = LogisticRegression()

Процесс обучения модели на подготовленных данных:

fit!(model, X_train, y_train)

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

predictions = predict(model, X_test)

Оценка качества модели с помощью различных метрик:

@sk_import metrics: accuracy_score acc = accuracy_score(y_test, predictions)

Классификации видов ирисов:

using ScikitLearn  @sk_import datasets: load_iris @sk_import model_selection: train_test_split @sk_import preprocessing: StandardScaler @sk_import linear_model: LogisticRegression @sk_import metrics: accuracy_score # да, такие вот импорты ;)  iris = load_iris() X, y = iris["data"], iris["target"]  scaler = StandardScaler() X_scaled = fit_transform(scaler, X)  X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3)  model = LogisticRegression() fit!(model, X_train, y_train)  predictions = predict(model, X_test)

Оптимизация и автоматическое дифференцирование

Zygote — это библиотека для автоматического дифференцирования в Julia, позволяет легко вычислять градиенты функций:

using Zygote  f(x) = 3x^2 + 2x + 1 df = gradient(f, 2)  # вычисляет градиент f в точке x=2 println(df)  # вывод: (14,)

g(x, y) = sin(x) + cos(y) dg = gradient(g, π/2, π)  # вычисление градиента по x и y println(dg)  # вывод: (-1.0, 0.0)

# функция потерь loss(x, y) = sum((x - y).^2)  # градиент функции потерь x, y = [1, 2, 3], [3, 2, 1] grad_loss = gradient(() -> loss(x, y), params([x, y])) println(grad_loss)

Также есть Optim, которая позволяет для оптимизации функций:

using Optim  f(x) = (x[1] - 2)^2 + (x[2] - 3)^2 res = optimize(f, [0.0, 0.0])  # начальная точка [0.0, 0.0] println(Optim.minimizer(res))  # ввод: близко к [2, 3]

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

f(x) = (x[1] - 1)^2 + (x[2] - 2)^2 ∇f(x) = gradient(f, x)[1]  res = optimize(f, ∇f, [0.0, 0.0], BFGS())  # BFGS метод println(Optim.minimizer(res))  # близко к [1, 2]

# функция потерь loss(x) = (x[1] - 3)^2 + (x[2] - 4)^2 ∇loss(x) = gradient(loss, x)[1]  initial_params = [0.0, 0.0] res = optimize(loss, ∇loss, initial_params, LBFGS()) println(Optim.minimizer(res))  # близко к [3, 4] 

Plots.jl

С помощью plost.jl можно визуализировать данные и т.п.

using Plots  # линейный графика plot([1, 2, 3, 4, 5], [2, 4, 1, 3, 7], label="линия", linewidth=2)

# гистограмма histogram(randn(1000), bins=15, label="частоты")

# график рассеяния scatter(randn(100), randn(100), color=:blue, label="точки")

---

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

Несмотря на то, что Julia все еще молодой язык и его сообщество не так велико, как у Python или R, он стремительно развивается, обогащается новыми библиотеками и возможностями.

Больше интересного из мира машинного обучения эксперты OTUS рассказывают в рамках онлайн-курсов. А в календаре мероприятий все желающие могут зарегистрироваться на заинтересовавший бесплатный вебинар.