Foundations-of-Machine-Learning

We're excited to be your gateway into machine learning. ML is a rapidly growing field that's buzzing with opportunity.

Julia слияние простоты и мощи в машинном обучении

Julia зародилась в 2009 году, благодаря усилиям четырех энтузиастов-разработчиков:

Джефф Безансон

Стефан Карпински

Вирал Би Шах

Алан Эдельман

Идея создания Julia зародилась в Массачусетском технологическом институте (MIT) благодаря совместной работе Алана Эдельмана, Джеффа Безансона и Стефана Карпински. Они обсуждали проблемы существующих языков программирования и искали способы улучшить производительность и удобство использования для научных вычислений. Позже к ним присоединился Вирал Б. Шах, который помогал с практическими аспектами разработки и внедрения языка.

Они стремились создать язык, который сочетал бы легкость Python, скорость C, динамичность Ruby, лингвистическую чистоту Lisp и возможности
математических систем вроде Matlab. Им удалось! Julia – это слияние простоты и мощи. Благодаря JIT-компиляции, код Julia может выполняться с скоростью, сопоставимой с кодом, написанным на C или Fortran.

Основные особенности Julia:

JIT-компиляция в Julia: Глубокий разбор 🚀

1️⃣ Что такое JIT-компиляция?

JIT (Just-In-Time) компиляция — это компромисс между интерпретацией и статической компиляцией.
В отличие от статической компиляции (C, C++, Rust), где код сначала компилируется в исполняемый файл, и интерпретации (Python, Ruby, JavaScript), где код выполняется построчно, JIT-компилятор компилирует код во время его выполнения.

Как это работает в Julia?
📌 Julia читается и анализируется как интерпретируемый язык.
📌 При первом вызове функции Julia компилирует её в машинный код с помощью JIT.
📌 Скомпилированная версия кэшируется и повторно используется.

📌 Пример: Демонстрация JIT-компиляции

function square(x)
    return x * x
end

println(square(10))  # Julia компилирует функцию square() перед первым вызовом
println(square(20))  # Использует уже скомпилированный код

✅ Первый вызов функции требует компиляции, но последующие вызовы мгновенные.

2️⃣ Почему Julia использует JIT?

Julia создана для научных вычислений и высокопроизводительных вычислений.
JIT позволяет получить гибкость Python и скорость C, объединяя:

Динамическую типизацию → гибкость
Статическую компиляцию → высокая скорость
Оптимизации LLVM → производительность

3️⃣ Как JIT ускоряет код?

Julia использует LLVM (Low-Level Virtual Machine) — мощную компиляторную инфраструктуру, которая:

Генерирует машинный код во время выполнения
Применяет продвинутые оптимизации (vectorization, inlining, loop unrolling)
Кэширует машинный код, чтобы избежать повторной компиляции

📌 Сравнение с интерпретацией

function simple_loop(n)
    s = 0
    for i in 1:n
        s += i
    end
    return s
end

println(simple_loop(1000000))

✅ Julia скомпилирует simple_loop() один раз, затем будет работать как нативный код.

4️⃣ Визуализация процесса компиляции

Julia позволяет посмотреть результат работы JIT-компилятора.

📌 Генерация LLVM-кода

Можно посмотреть, какой промежуточный код LLVM генерирует JIT:

using InteractiveUtils

function square(x::Int)
    return x * x
end

@code_llvm square(10)

✅ Выведет LLVM IR (Intermediate Representation), который затем будет оптимизирован.

📌 Генерация машинного кода

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

@code_native square(10)

✅ Julia покажет ассемблерный код, который выполняется процессором.

5️⃣ Кэширование JIT-компиляции

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

📌 Проверка времени выполнения первой и второй итерации

using BenchmarkTools

function compute(n)
    return sum(1:n)
end

println("Первый запуск:")
@btime compute(10^6)  # Компиляция + выполнение

println("Второй запуск:")
@btime compute(10^6)  # Только выполнение (уже скомпилировано)

✅ Второй запуск быстрее, потому что код уже скомпилирован!

6️⃣ Как избежать повторной компиляции?

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

📌 Пример: Почему JIT может работать медленнее

function bad_function(x)
    return x + 10
end

@btime bad_function(10)  # Быстро (Int)
@btime bad_function(10.5)  # Компиляция заново (Float64)

✅ Julia компилирует отдельные версии bad_function для Int и Float64.
Решение: используйте строгую типизацию!

function good_function(x::Int)
    return x + 10
end

✅ Теперь Julia не компилирует новую версию для Float64.

7️⃣ Оптимизация JIT-компиляции

📌 Используйте `precompile()`

Функция precompile() позволяет скомпилировать код заранее.

function expensive_function(x::Int)
    return x * x + 10
end

precompile(expensive_function, (Int,))

✅ Теперь expensive_function(10) будет работать быстрее с первого вызова.

📌 Компиляция пакетов

Чтобы ускорить загрузку больших пакетов, используйте:

using PackageCompiler
create_sysimage(:MyPackage, sysimage_path="MyPackage.so")

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

8️⃣ JIT-компиляция vs. AOT-компиляция

Подход	JIT (Julia, Java, Python (PyPy))	AOT (C, Rust, Go)
Когда компилируется код?	Во время выполнения	До выполнения
Гибкость	Динамическая типизация, возможность изменения кода	Фиксированные типы, строгая компиляция
Скорость старта	Медленнее, т.к. код компилируется во время запуска	Быстрее, код уже скомпилирован
Оптимизация во время работы	Может оптимизировать "на лету"	Оптимизирован заранее
Использование памяти	Может быть выше из-за кэширования и оптимизации	Оптимизировано заранее

✅ Julia использует JIT-компиляцию, но может приближаться к AOT с PackageCompiler!

🎯 Итог

✅ JIT-компиляция в Julia позволяет:

Автоматически компилировать код "на лету" 🏎
Кэшировать скомпилированные функции для ускорения повторных вызовов 🔥
Использовать LLVM-оптимизации для максимальной производительности 💪
Смотреть машинный код с @code_llvm и @code_native 👀
Оптимизировать загрузку пакетов через precompile() и PackageCompiler 🛠

💡 Julia объединяет гибкость динамического языка и скорость компилируемого кода! 🚀

Типизация в Julia 🚀

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

1️⃣ Типизация в Julia: Динамическая vs. Статическая

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

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

📌 Динамическая типизация (гибкость, но медленнее)

function add(a, b)  # Типы не указаны
    return a + b
end

println(add(10, 20))   # 30
println(add(10.5, 20.3)) # 30.8

✅ Минус: Julia не знает тип a и b заранее → требуется определение типа во время выполнения (что может замедлить код).

📌 Статическая типизация (оптимизированная производительность)

function add(a::Int, b::Int)
    return a + b
end

println(add(10, 20))  # 30
println(add(10.5, 20.3))  # Ошибка: аргументы должны быть `Int`

✅ Плюс: Julia теперь знает, что a и b должны быть Int, а значит не будет проверок типов в рантайме.

📌 Использование параметризованных типов

Мы можем писать гибкие, но оптимизированные функции:

function add(a::T, b::T) where T <: Number
    return a + b
end

println(add(10, 20))  # 30
println(add(10.5, 20.3))  # 30.8

✅ Гибкость + скорость:

T <: Number означает, что оба аргумента должны быть одного типа, но тип может быть Int, Float64, BigInt и др.
Julia заранее компилирует отдельные версии функции для каждого типа T → это ускоряет выполнение.

2️⃣ Влияние типизации на использование памяти

Julia предоставляет возможность экономии памяти, если мы избегаем неявного использования Any и используем строгую типизацию.

📌 Пример использования памяти без оптимизации

a = [1, 2, 3, 4, 5]  # Массив типа Vector{Int}
b = [1, "hello", 3.5, :symbol]  # Разные типы → Vector{Any}

using Base

println(sizeof(a))  # Вывод: 40 байт
println(sizeof(b))  # Вывод: 32 байта (но на самом деле массив хранит указатели!)

Почему b занимает меньше памяти?
Vector{Any} не хранит значения непосредственно, а хранит ссылки (указатели) на объекты разного типа, что требует дополнительных аллокаций памяти и замедляет доступ.

📌 Как экономить память в Julia?

Явно указывать тип массива

a = Int64[1, 2, 3, 4, 5]  # Массив из Int64
b = Any[1, "hello", 3.5, :symbol]  # Неоптимальный массив

✅ Vector{Int64} использует однотипные элементы → работает быстрее и потребляет меньше памяти.

Использовать Struct с явными типами

struct Person1  # Оптимальный вариант (фиксированные типы)
    name::String
    age::Int
end

mutable struct Person2  # Неоптимальный вариант (динамические типы)
    name
    age
end

p1 = Person1("Alice", 30)
p2 = Person2("Bob", 40)

println(sizeof(p1))  # 16 байт
println(sizeof(p2))  # 8 байт (но требует больше аллокаций из-за `Any`)

✅ Лучше использовать фиксированные типы в структурах → меньше аллокаций, быстрее доступ.

3️⃣ Пример оптимизации памяти с `@allocated`

Julia позволяет замерять количество выделенной памяти с помощью @allocated.

📌 Пример без оптимизации (медленно)

function bad_sum(arr)
    s = 0
    for i in arr
        s += i
    end
    return s
end

arr = [1.0, 2.0, 3.0, 4.0]  # Float64 массив
println(@allocated bad_sum(arr))  # Выделено: ~160 байт

❌ Почему так много памяти?

Julia не знает тип s заранее (из-за s = 0, где 0 – это Int, а arr содержит Float64).

✅ Исправленный вариант (быстрее, меньше памяти)

function good_sum(arr)
    s::Float64 = 0.0  # Явно указываем тип аккумулятора
    for i in arr
        s += i
    end
    return s
end

println(@allocated good_sum(arr))  # Выделено: ~0 байт

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

Быстрее: Julia теперь не выполняет лишние проверки типов в цикле.
Меньше памяти: Отсутствуют ненужные аллокации.

4️⃣ Вывод типов в Julia (`typeof`, `eltype`)

x = 42
y = 3.14
z = "Hello"

println(typeof(x))  # Int64
println(typeof(y))  # Float64
println(typeof(z))  # String

arr = [1, 2, 3]
println(eltype(arr))  # Int64 (тип элементов массива)

🎯 Используйте typeof() и eltype() для проверки типов в коде.

5️⃣ Использование `@code_warntype` для оптимизации типов

Julia позволяет проверить, где могут быть проблемы с типами, с помощью @code_warntype.

📌 Пример неоптимального кода

function bad_function(a, b)
    return a + b
end

@code_warntype bad_function(10, 20.5)

✅ Если Julia покажет Any в выводе @code_warntype, значит код не оптимизирован.

Используйте явные аннотации типов, чтобы избежать этого.

💡 Итог

Явное указание типов ускоряет код 🏎
Однотипные массивы (Vector{T}) используют меньше памяти, чем Vector{Any} 🔥
Используйте @allocated и @code_warntype для оптимизации 🛠
Оптимизируйте структуры (struct) с фиксированными типами 💡

💡 Julia даёт гибкость динамической типизации, но при правильном использовании типов код становится таким же быстрым, как в C/C++! 🚀

Supertype и Subtype в Julia 🚀

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

1️⃣ Что такое Supertype и Subtype?

Supertype – это родительский (базовый) тип, который объединяет несколько подтипов.
Subtype – это наследуемый (дочерний) тип, который является более специфичным вариантом супертипа.

В Julia все типы являются подтипами самого общего типа Any:

Int <: Number  # true (Int - это подтип Number)
Float64 <: Number  # true (Float64 - подтип Number)
String <: Any  # true (String - подтип Any)

✅ Int и Float64 — это разные числа, но они оба являются подтипами Number.

2️⃣ Определение собственного супертипа

В Julia можно создавать свои абстрактные типы и наследовать от них.

📌 Пример: Создание абстрактного типа `Shape`

abstract type Shape end  # Абстрактный супертип

struct Circle <: Shape  # Круг - подтип Shape
    radius::Float64
end

struct Rectangle <: Shape  # Прямоугольник - подтип Shape
    width::Float64
    height::Float64
end

✅ Теперь Circle и Rectangle являются подтипами Shape.

📌 Проверка принадлежности к супертипу

println(Circle <: Shape)  # true
println(Rectangle <: Shape)  # true
println(Int <: Shape)  # false

✅ Circle и Rectangle являются подтипами Shape, но Int – нет.

3️⃣ Использование Supertype в функциях

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

function area(shape::Shape)
    error("Function area() not implemented for $(typeof(shape))")
end

function area(c::Circle)
    return π * c.radius^2
end

function area(r::Rectangle)
    return r.width * r.height
end

📌 Теперь можно вычислять площадь разных фигур с одним API:

c = Circle(5.0)
r = Rectangle(4.0, 6.0)

println(area(c))  # 78.54
println(area(r))  # 24.0

✅ Julia автоматически выбирает нужную реализацию через множественную диспетчеризацию! 🚀

4️⃣ Использование `supertype()`

Julia позволяет узнать супертип любого типа:

println(supertype(Int64))  # Signed
println(supertype(Float64))  # AbstractFloat
println(supertype(AbstractFloat))  # Number
println(supertype(Number))  # Any

✅ Можно прослеживать всю иерархию типов.

5️⃣ Использование `subtypes()`

Можно узнать все подтипы определённого типа:

println(subtypes(Number))  
# [BigFloat, BigInt, Bool, Complex, Float16, Float32, Float64, Int128, Int16, Int32, Int64, Int8, Rational, UInt128, UInt16, UInt32, UInt64, UInt8]

println(subtypes(AbstractFloat))  
# [BigFloat, Float16, Float32, Float64]

✅ Помогает изучать иерархию типов.

6️⃣ Различие `abstract type` и `struct`

📌 `abstract type` (абстрактные типы)

Нельзя создавать экземпляры
Используются для организации подтипов
Удобны для обобщённого программирования

abstract type Animal end

📌 `struct` (конкретные типы)

Можно создавать экземпляры
Поддерживают наследование от abstract type
Оптимизированы для производительности

struct Dog <: Animal
    name::String
end

✅ Используйте struct для конкретных объектов, а abstract type — для концепций.

7️⃣ Пример с кастомной иерархией типов

Создадим иерархию транспорта:

abstract type Vehicle end  # Супертип Транспорт

struct Car <: Vehicle  # Машина
    speed::Float64
end

struct Bicycle <: Vehicle  # Велосипед
    gear::Int
end

function move(v::Vehicle)
    println("This vehicle moves...")
end

function move(c::Car)
    println("Car moves at $(c.speed) km/h.")
end

function move(b::Bicycle)
    println("Bicycle moves with $(b.gear) gears.")
end

c = Car(120.0)
b = Bicycle(21)

move(c)  # Car moves at 120.0 km/h.
move(b)  # Bicycle moves with 21 gears.

✅ Julia автоматически выбирает нужную реализацию функции move().

🎯 Итог

supertype(T) возвращает супертип T
subtypes(T) показывает все подтипы T
Абстрактные типы (abstract type) нужны для организации иерархии
Конкретные типы (struct) наследуют от abstract type
Множественная диспетчеризация делает код гибким и производительным

💡 Используйте Supertype и Subtype для организации кода и улучшения читаемости! 🚀

Многопоточность в Julia 🚀

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

🔥 Основные особенности многопоточности в Julia

Легкость использования – встроенная поддержка через модуль Base.Threads
Динамическое распределение потоков – Julia автоматически распределяет задачи по доступным потокам
Поддержка атомарных операций – предотвращает гонки данных
Многопоточность без глобальной блокировки (GIL) – в отличие от Python, Julia не ограничена GIL и может эффективно использовать все ядра процессора
Гибкость управления – можно задавать количество потоков с помощью переменной окружения JULIA_NUM_THREADS

🛠 Настройка многопоточности

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

Способы задания количества потоков

1. В терминале перед запуском Julia:

export JULIA_NUM_THREADS=4  # Linux/macOS
set JULIA_NUM_THREADS=4  # Windows (cmd)
$env:JULIA_NUM_THREADS="4"  # Windows (PowerShell)
julia

2. Внутри Julia-кода (только для чтения):

using Base.Threads
println("Number of Threads: ", nthreads())

✅ Выведет: Number of Threads: 4 (если задано 4 потока)

🏎 Пример 1: Ускорение вычислений с `@threads`

В Julia многопоточность реализуется через макрос @threads, который распределяет итерации цикла между потоками.

using Base.Threads

function threaded_sum(arr)
    n = length(arr)
    sums = zeros(nthreads())  # Создаем массив для частичных сумм

    @threads for i in 1:nthreads()
        # Разбиваем массив по потокам
        for j in i:nthreads():n
            sums[i] += arr[j]
        end
    end

    return sum(sums)  # Суммируем результаты всех потоков
end

arr = rand(1:100, 10^6)  # Создаем массив случайных чисел
println("Sum: ", threaded_sum(arr))  # Ускоренный расчет суммы

✅ Этот код выполняет суммирование быстрее, чем обычный цикл for.

🛡 Атомарные операции (без гонок данных)

Если несколько потоков изменяют одну переменную, это может привести к гонке данных (race condition).
Решение – использование атомарных переменных через Atomic{T}.

Пример 2: Потокобезопасное увеличение счетчика

using Base.Threads

function threaded_increment(n)
    count = Atomic{Int}(0)  # Атомарная переменная
    @threads for i in 1:n
        atomic_add!(count, 1)  # Безопасное увеличение
    end
    return count[]
end

println("Final Count: ", threaded_increment(10^6))  # Ожидаемый результат: 1000000

✅ Использование Atomic{T} гарантирует, что увеличение выполняется корректно, даже если несколько потоков изменяют переменную одновременно.

⚡ Пример 3: Параллельная обработка матрицы

using Base.Threads

function threaded_matrix_sum(A)
    rows, cols = size(A)
    result = zeros(rows)

    @threads for i in 1:rows
        result[i] = sum(A[i, :])  # Суммируем строку параллельно
    end

    return result
end

A = rand(1000, 1000)  # Большая матрица
println(threaded_matrix_sum(A))  # Быстрая обработка строк

✅ Этот код ускоряет суммирование строк в большой матрице.

🔄 Пример 4: Parallel map (`Threads.@spawn`)

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

using Base.Threads

function parallel_map(f, arr)
    tasks = [Threads.@spawn f(x) for x in arr]  # Запускаем вычисления
    return [fetch(t) for t in tasks]  # Ожидаем завершения
end

result = parallel_map(x -> x^2, 1:10)
println(result)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

✅ Этот код применяет функцию f(x) = x^2 к каждому элементу массива параллельно.

🆚 Многопоточность vs. Многопроцессорность

Характеристика	Многопоточность (Threads)	Многопроцессорность (Distributed.jl)
Количество ядер	Использует одно ядро с разными потоками	Использует несколько ядер (процессов)
Глобальная память	Общая память между потоками	Каждый процесс имеет свою память
Гонки данных	Возможны, требуется синхронизация	Нет гонок данных, процессы изолированы
Оверхед	Низкий, быстрый запуск	Выше из-за обмена данными между процессами
Используемый модуль	`Base.Threads`	`Distributed`

✅ Когда использовать многопоточность?

Для разделения вычислений внутри одного процесса
Если нужно общая память между потоками
Для ускорения работы с массивами и матрицами

✅ Когда лучше использовать Distributed.jl?

Если нужно использовать несколько ядер процессора
Если можно разбить задачу на независимые подзадачи
Если нужно распараллелить большие вычисления на кластере

🔗 Полезные ссылки

📖 Официальная документация по многопоточности
📘 Блог о многопоточности в Julia
💻 Распределенные вычисления (Distributed.jl)

🎯 Итоги:

Julia не имеет GIL, поэтому многопоточность действительно ускоряет код.
Использование @threads позволяет разделять вычисления между потоками.
Атомарные переменные (Atomic{T}) предотвращают гонки данных.
Threads.@spawn даёт гибкость для асинхронных задач.
Выбор между Threads и Distributed зависит от типа задачи.

💡 Многопоточность в Julia – мощный инструмент для работы с вычислениями и данными! 🚀

Множественная диспетчеризация в Julia 🚀

Одна из самых мощных особенностей Julia — множественная диспетчеризация (multiple dispatch). Она позволяет Julia выбирать, какую версию функции использовать в зависимости от типов всех её аргументов. Это делает код гибким, быстрым и выразительным.

🔥 Как работает множественная диспетчеризация?

В отличие от языков, где перегрузка функций основывается на одном аргументе (например, Python, Java, C++), в Julia функция может иметь разные реализации для разных комбинаций типов аргументов.

📌 Простой пример

function say_hello(name::String)
    println("Hello, $name!")
end

function say_hello(name::Symbol)
    println("Hello, the symbol :$name!")
end

say_hello("Alice")  # "Hello, Alice!"
say_hello(:Alice)   # "Hello, the symbol :Alice!"

✅ Julia автоматически выбирает правильную версию say_hello() на основе типа аргумента.

🎯 Зачем нужна множественная диспетчеризация?

📌 Оптимизация кода: Julia компилирует специализированные версии функций для конкретных типов, что делает код быстрым.
🛠 Гибкость: Позволяет легко адаптировать код под разные типы данных.
🚀 Производительность: Julia генерирует эффективный машинный код, используя JIT-компиляцию.

📌 Пример с арифметикой

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

function add(a::Int, b::Int)
    return a + b
end

function add(a::Float64, b::Float64)
    return a + b
end

function add(a::String, b::String)
    return a * " " * b  # Конкатенация строк с пробелом
end

println(add(10, 20))         # 30
println(add(10.5, 20.3))     # 30.8
println(add("Hello", "Julia")) # "Hello Julia"

✅ Julia автоматически выбирает нужную функцию в зависимости от типов аргументов.

🎭 Полиморфизм через абстрактные типы

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

function add(a::Number, b::Number)
    return a + b
end

println(add(10, 5.5))  # 15.5 (Int + Float работает)
println(add(3.2, 1.8))  # 5.0

✅ Теперь add() работает для любых числовых типов.

⚡ Использование параметрических типов

Можно явно указывать параметризованные типы:

function add_same_type{T <: Number}(a::T, b::T)
    return a + b
end

println(add_same_type(5, 10))   # 15
println(add_same_type(2.5, 3.5)) # 6.0

✅ Эта версия add_same_type() работает только для аргументов одного типа!

🚀 Множественная диспетчеризация в сложных структурах

Допустим, у нас есть двухмерные фигуры: Круг и Прямоугольник.

abstract type Shape end  # Абстрактный тип

struct Circle <: Shape
    radius::Float64
end

struct Rectangle <: Shape
    width::Float64
    height::Float64
end

# Функции для вычисления площади
function area(shape::Circle)
    return π * shape.radius^2
end

function area(shape::Rectangle)
    return shape.width * shape.height
end

c = Circle(5.0)
r = Rectangle(4.0, 6.0)

println("Area of Circle: ", area(c))  # 78.54
println("Area of Rectangle: ", area(r))  # 24.0

✅ Julia автоматически вызывает нужную версию area() на основе типа объекта.

🔄 Перегрузка операторов через множественную диспетчеризацию

Julia позволяет определять поведение операторов для новых типов данных:

struct Point
    x::Float64
    y::Float64
end

# Перегрузка оператора +
function Base.:+(p1::Point, p2::Point)
    return Point(p1.x + p2.x, p1.y + p2.y)
end

p1 = Point(2.0, 3.0)
p2 = Point(4.0, 1.0)

p3 = p1 + p2
println("New point: (", p3.x, ", ", p3.y, ")")  # (6.0, 4.0)

✅ Теперь можно складывать точки с помощью +, как в векторной алгебре!

🎯 Когда использовать множественную диспетчеризацию?

✔ Когда нужна высокая производительность
✔ Когда функции должны работать с разными типами
✔ Когда код должен быть расширяемым
✔ Когда важно избегать кучи if-else проверок типов

💡 Итоги:

Множественная диспетчеризация в Julia:

🔥 Автоматически выбирает оптимальную функцию на основе типов аргументов.
🏎 Ускоряет вычисления благодаря JIT-компиляции.
🎯 Позволяет писать чистый, выразительный код без сложных if-else проверок.
🔄 Подходит для математических вычислений, физики, машинного обучения и др..

💡 Julia – один из немногих языков, где множественная диспетчеризация встроена в ядро! 🚀

Machine Learning и библиотеки Julia для ML

Jupyter Notebook vs. Pluto.jl в Julia 🚀

В Julia для работы с интерактивными вычислениями доступны два основных ноутбука:

Jupyter Notebook (через IJulia.jl)
Pluto.jl (нативный ноутбук Julia)

Давайте же разберём ниже, какие у них отличия, преимущества и когда их использовать.

1️⃣ Jupyter Notebook в Julia

Jupyter Notebook – это платформа для интерактивного кода, поддерживающая Python, Julia, R и другие языки.
Julia использует пакет IJulia.jl, который позволяет запускать Julia в Jupyter Notebook.

📌 Установка Jupyter Notebook для Julia

using Pkg
Pkg.add("IJulia")  # Устанавливаем поддержку Jupyter

Затем запускаем Jupyter:

using IJulia
notebook()

✅ Julia откроется в Jupyter Notebook в браузере.

🔹 Преимущества Jupyter Notebook

✔ Поддерживает Python, Julia, R и другие языки
✔ Можно использовать богатые библиотеки визуализации (Plots.jl, Gadfly.jl)
✔ Поддержка Markdown и LaTeX
✔ Хорошо работает в облачных сервисах (Google Colab, Kaggle)

🔻 Недостатки Jupyter Notebook

❌ Ячейки не связаны между собой – если изменить одну ячейку, другие могут перестать работать
❌ Код сохраняется в *.ipynb – не так удобно для работы с Git
❌ Может потреблять много памяти, если ноутбук долго работает

2️⃣ Pluto.jl – Нативный Notebook в Julia

Pluto.jl – это интерактивный ноутбук, написанный на Julia.
Он создан специально для работы с Julia-кодом, поэтому имеет некоторые преимущества перед Jupyter.

📌 Установка Pluto.jl

using Pkg
Pkg.add("Pluto")  # Устанавливаем Pluto

Затем запускаем Pluto:

using Pluto
Pluto.run()

✅ Pluto откроется в браузере, как Jupyter Notebook, но будет работать иначе.

🔹 Преимущества Pluto.jl

✔ Автоматическая реактивность – изменения кода обновляют всё, как в Excel
✔ Чистая и упорядоченная среда – нет "битых" ячеек, всё пересчитывается автоматически
✔ Меньшее потребление памяти – не хранит устаревшие переменные
✔ Лучше для воспроизводимых исследований
✔ Сохранение в *.jl (обычный Julia-код) – удобнее для работы с Git

🔻 Недостатки Pluto.jl

❌ Только Julia (нельзя запустить Python, R и другие языки)
❌ Нет свободы в порядке выполнения ячеек – всё выполняется в строгом порядке
❌ Не поддерживает !pip install, так как всё должно быть в Julia

3️⃣ Сравнение Jupyter vs. Pluto.jl

🔹 Характеристика	📝 Jupyter Notebook	🔥 Pluto.jl
Языки	Julia, Python, R и др.	Только Julia
Выполнение ячеек	В любом порядке	Строго сверху вниз
Автоматические обновления	❌ Нет	✅ Да
Работа с памятью	⚠️ Может накапливать ненужные данные	✅ Оптимизирован
Формат файлов	`.ipynb`	`.jl`
Git-friendly	❌ Плохо совместим с Git	✅ Удобно хранить и версионировать
Лучше подходит для	Python + Julia + ML	Чистый Julia-код

4️⃣ Когда использовать Jupyter Notebook?

✅ Если вам нужны Python и Julia в одном ноутбуке
✅ Если вы работаете в Google Colab, Kaggle или Azure Notebooks
✅ Если вам важны библиотеки визуализации и machine learning

5️⃣ Когда использовать Pluto.jl?

✅ Если вы пишете код только на Julia
✅ Если вам важна реактивность (пересчёт всех ячеек)
✅ Если вы работаете в научных исследованиях, численных методах
✅ Если вы хотите легко коммитить код в Git

🎯 Итог

Jupyter – универсальный инструмент для ML, Python и Julia
Pluto.jl – современный интерактивный ноутбук, оптимизированный под Julia
Pluto лучше для чистого Julia-кода, а Jupyter удобнее, если вы используете Python

💡 Выбор зависит от ваших задач! 🚀

Flux.jl – Глубокое обучение в Julia 🚀

1️⃣ Что такое Flux.jl?

Flux.jl – это основная библиотека для глубокого обучения в Julia.
Она предлагает интуитивный, гибкий и производительный API для создания нейронных сетей, градиентного спуска и автоматического дифференцирования.

Почему Flux.jl? ✅ Гибкость – легко писать нестандартные модели
✅ Высокая производительность – использует GPU (CUDA.jl)
✅ Автоматическое дифференцирование – через Zygote.jl
✅ Минималистичный API – код читается, как математические выражения

2️⃣ Основные компоненты Flux.jl

Flux предлагает предопределенные слои, функции активации, автоматическое вычисление градиентов и оптимизаторы.

🔹 2.1 Слои (Layers)

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

📌 Полносвязный слой (`Dense`)

using Flux

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

✅ Вход: 10 нейронов
✅ Выход: 5 нейронов
✅ Функция активации: σ (сигмоидальная)

📌 Сверточный слой (`Conv`)

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

✅ Фильтр: 3x3
✅ Входные каналы: 1 (например, градации серого)
✅ Выходные каналы: 16
✅ Функция активации: relu

🔹 2.2 Функции активации

Flux поддерживает стандартные функции активации:

relu_layer = Dense(10, 5, relu)  # Полносвязный слой с ReLU

Функция	Описание
`σ` (сигмоид)	( \sigma(x) = \frac{1}{1 + e^{-x}} )
`relu`	( \max(0, x) )
`tanh`	Гиперболический тангенс

🔹 2.3 Оптимизаторы

Flux предоставляет различные методы градиентного спуска:

opt = Descent(0.01)  # SGD (градиентный спуск) с шагом 0.01
opt_adam = ADAM(0.001)  # Оптимизатор Adam

Оптимизатор	Описание
`Descent(η)`	Стохастический градиентный спуск (SGD)
`Adam(η)`	Adam – более быстрый SGD
`RMSprop(η)`	Улучшенный вариант SGD

🔹 2.4 Функции потерь

Функции потерь используются для обучения модели.

loss(x, y) = Flux.Losses.crossentropy(model(x), y)  # Кросс-энтропия

Функция потерь	Описание
`crossentropy(ŷ, y)`	Кросс-энтропия (для классификации)
`mse(ŷ, y)`	Среднеквадратичная ошибка (MSE, для регрессии)

3️⃣ Пример: Классификация MNIST (Распознавание цифр)

Создадим нейронную сеть для классификации изображений (28x28 пикселей) из MNIST.

🔹 3.1 Установка зависимостей

using Pkg
Pkg.add(["Flux", "Flux.Data.MNIST", "Statistics"])

🔹 3.2 Загрузка данных

using Flux, Flux.Data.MNIST, Statistics
using Flux: onehotbatch, crossentropy, throttle
using Base.Iterators: repeated

# Загружаем изображения и метки
images = float.(reshape(hcat(float.(MNIST.images())...), 28 * 28, :))
labels = onehotbatch(MNIST.labels(), 0:9)  # One-hot encoding

# Разделяем на обучающую и тестовую выборки
train_indices = 1:60000
test_indices = 60001:70000

x_train, y_train = images[:, train_indices], labels[:, train_indices]
x_test, y_test = images[:, test_indices], labels[:, test_indices]

✅ Данные загружаются в формате Float32, а метки переводятся в one-hot encoding.

🔹 3.3 Определение модели

model = Chain(
    Dense(28*28, 64, relu),  # Входной слой: 784 нейрона → 64
    Dense(64, 10),  # Выходной слой: 64 → 10 классов
    softmax  # Функция активации для классификации
)

✅ Модель:

Полносвязный слой 28*28 → 64 (ReLU)
Полносвязный слой 64 → 10 (выход на 10 классов)
softmax для предсказания вероятностей

🔹 3.4 Функция потерь и оптимизатор

loss(x, y) = crossentropy(model(x), y)
opt = ADAM()  # Оптимизатор Adam

✅ Используем crossentropy (т.к. это задача классификации)
✅ Оптимизатор ADAM для быстрой сходимости

🔹 3.5 Обучение модели

dataset = repeated((x_train, y_train), 200)  # 200 эпох
evalcb = () -> @show(loss(x_train, y_train))  # Выводим ошибку

Flux.train!(loss, params(model), dataset, opt, cb = throttle(evalcb, 10))

✅ train!() автоматически выполняет обратное распространение ошибки.

🔹 3.6 Оценка модели

y_pred = model(x_test)  # Предсказания модели
accuracy = mean(onecold(y_pred) .== onecold(y_test))  # Оценка точности
println("Accuracy: ", accuracy)

✅ Если всё правильно, точность будет ~97%

4️⃣ Работа с GPU в Flux.jl

Flux поддерживает вычисления на GPU (CUDA).
Для работы с NVIDIA GPU нужно установить CUDA.jl:

using Pkg
Pkg.add("CUDA")  # Устанавливаем поддержку CUDA

Затем перемещаем модель и данные на GPU:

using CUDA

model = model |> gpu  # Перемещение модели на GPU
x_train, y_train = x_train |> gpu, y_train |> gpu  # Данные на GPU

# Теперь можно обучать модель на GPU!
Flux.train!(loss, params(model), dataset, opt)

✅ Ускорение в 10-50 раз на больших сетях!

🎯 Итог

🔹 Flux.jl – мощная библиотека для глубокого обучения
🔹 Поддерживает нейросети (Dense, Conv), оптимизаторы (Adam, SGD), функции потерь (MSE, CrossEntropy)
🔹 Гибкость позволяет легко строить кастомные модели
🔹 Поддержка GPU через CUDA.jl

MLJ

MLJ (Machine Learning in Julia) предоставляет мощный и гибкий унифицированный интерфейс для машинного обучения в языке Julia. Он поддерживает широкий спектр моделей машинного обучения , предоставляет инструменты для предварительной обработки данных, построения конвейеров (pipelines) и проведения экспериментов.

🔥 Основные возможности MLJ:

Единый интерфейс 🏗️
- Позволяет использовать модели из ScikitLearn.jl, XGBoost.jl, Flux.jl и других библиотек.
- Унифицированный API для обучения, предсказаний, валидации и оценки моделей.
Гибкость и модульность 🔄
- Позволяет легко комбинировать разные модели в конвейеры (pipelines).
- Поддерживает гиперпараметрический поиск (Hyperparameter tuning).
Обучение с контролем производительности 🚀
- Поддерживает CPU и GPU для вычислений.
- Легко масштабируется при работе с большими данными.
Оценка качества моделей 📊
- Поддержка кросс-валидации и других методов оценки.
- Автоматическая метрика для задач классификации, регрессии, кластеризации.
Интеграция с DataFrames.jl 🛠️
- Удобная работа с табличными данными.
- Возможность фильтрации, трансформации и визуализации.

📌 Пример использования MLJ в Julia

using MLJ
using DataFrames, Random

# Загружаем датасет
iris = MLJ.@load_iris

# Разделяем данные на тренировочную и тестовую выборки
train, test = partition(eachindex(iris.target), 0.7, rng=123)

# Выбираем модель: Дерево решений
DecisionTree = @load DecisionTreeClassifier pkg=DecisionTree

# Создаем модель
model = DecisionTree(max_depth=3)

# Заворачиваем данные в MLJ-совместимую таблицу
X = select(iris, Not(:target))
y = iris.target

# Создаем машинное обучение в MLJ
mach = machine(model, X, y)

# Обучаем модель
fit!(mach, rows=train)

# Делаем предсказания
y_pred = predict(mach, rows=test)

# Оцениваем качество модели
accuracy(y_pred, y[test])

🔗 Полезные ресурсы:

MLJ отлично подходит для тех, кто ищет мощную и гибкую ML-библиотеку в Julia с возможностью интеграции с современными фреймворками! 🚀

ScikitLearn.jl – Scikit-Learn API в Julia 🦾

ScikitLearn.jl — это интерфейс для машинного обучения в Julia, который предоставляет API, схожий с Scikit-Learn в Python. Он делает процесс обучения моделей и их использования интуитивно понятным для пользователей, уже знакомых с Scikit-Learn, но при этом использует производительность Julia.

🚀 Особенности ScikitLearn.jl

Знакомый API, похожий на Scikit-Learn
- Методы fit!, predict, transform, score, pipeline работают аналогично Python.
Интерфейс к популярным ML-библиотекам Julia
- Поддержка моделей из DecisionTree.jl, MLJ.jl, XGBoost.jl, Flux.jl и других.
Высокая производительность Julia
- Использует компилятор LLVM для быстрого исполнения кода.
- Возможность работы на CPU и GPU.
Интеграция с DataFrames.jl и другими библиотеками Julia
- Позволяет использовать табличные данные так же, как в pandas.
Конвейеры (pipelines)
- Поддерживает создание последовательных ML-конвейеров, как в sklearn.pipeline.Pipeline.

📌 Пример использования ScikitLearn.jl

1️⃣ Установка и импорт библиотеки

using Pkg
Pkg.add("ScikitLearn")

using ScikitLearn
using DataFrames
using Random
using DecisionTree

2️⃣ Простая классификация (DecisionTree)

@sk_import datasets: load_iris
@sk_import tree: DecisionTreeClassifier

# Загружаем датасет
iris = load_iris()
X = iris["data"]  # Признаки
y = iris["target"]  # Целевая переменная

# Разделяем данные
Random.seed!(42)
train_idx = randperm(length(y))[1:Int(0.7 * length(y))]
test_idx = setdiff(1:length(y), train_idx)

X_train, X_test = X[train_idx, :], X[test_idx, :]
y_train, y_test = y[train_idx], y[test_idx]

# Создаем модель (дерево решений)
model = DecisionTreeClassifier(max_depth=3)

# Обучаем модель
ScikitLearn.fit!(model, X_train, y_train)

# Предсказываем
y_pred = ScikitLearn.predict(model, X_test)

# Оцениваем точность
accuracy = sum(y_pred .== y_test) / length(y_test)
println("Accuracy: ", accuracy)

✅ Результат: Accuracy: 0.95 (примерно, зависит от seed)

3️⃣ Использование Pipeline (Конвейера)

@sk_import preprocessing: StandardScaler
@sk_import svm: SVC
@sk_import pipeline: Pipeline

# Создаем конвейер: стандартизация + SVM
clf = Pipeline([
    ("scaler", StandardScaler()),
    ("svm", SVC(kernel="linear", C=1.0))
])

# Обучаем конвейер
fit!(clf, X_train, y_train)

# Предсказание
y_pred_pipe = predict(clf, X_test)

# Точность
accuracy_pipe = sum(y_pred_pipe .== y_test) / length(y_test)
println("Pipeline Accuracy: ", accuracy_pipe)

🔥 Ключевые отличия от Python Scikit-Learn

Функция	Scikit-Learn (Python)	ScikitLearn.jl (Julia)
API	`fit()`, `predict()`, `transform()`	`fit!()`, `predict()`, `transform()`
Подключение моделей	Встроенные в `sklearn`	Требуется импорт (`@sk_import`)
Производительность	Python (интерпретируемый)	Julia (компилируемый, быстрее)
Совместимость с pandas	`pandas.DataFrame`	`DataFrames.jl`
Работа с GPU	Ограничена	Полноценная поддержка

📚 Полезные ресурсы

🔗 Официальная документация
🔗 Примеры использования

Plots.jl

Plots.jl – мощная визуализация данных в Julia 📊✨

Plots.jl — это одна из самых мощных и гибких библиотек для построения графиков в Julia. Она поддерживает различные backend'ы (библиотеки отрисовки), что позволяет легко переключаться между ними в зависимости от ваших задач.

🚀 Ключевые возможности Plots.jl

Универсальный API
- Позволяет переключаться между разными рендерерами (GR, PyPlot, Plotly, PGFPlotsX и др.), не меняя код.
Гибкость настройки
- Можно изменять цвета, метки, размеры, стили линий, шрифты и многое другое.
Поддержка анимации 🎥
- Позволяет создавать GIF-анимации и интерактивные графики.
Совместимость с DataFrames.jl, StatsPlots.jl, Makie.jl
- Интеграция с библиотеками для работы с данными и статистикой.
Работа с 2D и 3D-графиками
- Поддержка гистограмм, плотностей, scatter-плотов, 3D-сеток и поверхностей.

📌 Простая установка

using Pkg
Pkg.add("Plots")  # Установка

📊 Примеры использования

1️⃣ Базовый график (линейный)

using Plots

# Данные
x = 0:0.1:10
y = sin.(x)

# Строим график
plot(x, y, label="sin(x)", linewidth=2, color=:blue)

# Добавляем заголовок и оси
title!("Sine Function")
xlabel!("X-axis")
ylabel!("Y-axis")

✅ Результат: График синусоиды с синим цветом и подписью.

2️⃣ Добавление нескольких графиков

plot(x, sin.(x), label="sin(x)", linewidth=2, color=:blue)
plot!(x, cos.(x), label="cos(x)", linewidth=2, color=:red)  # `plot!` добавляет график к существующему

✅ Результат: Графики синуса и косинуса на одном поле.

3️⃣ Точечный (scatter) график

scatter(1:10, rand(10), label="Random Points", marker=:circle, color=:purple)

✅ Результат: График случайных точек с фиолетовыми маркерами.

4️⃣ Гистограмма (histogram)

histogram(randn(1000), bins=30, color=:green, label="Random Data")

✅ Результат: Гистограмма нормального распределения.

5️⃣ Трёхмерный график (3D Plot)

x = -2:0.1:2
y = -2:0.1:2
z = [sin(xi) * cos(yi) for xi in x, yi in y]

plot3d(x, y, z, st=:surface, color=:viridis)

✅ Результат: 3D поверхность с цветовой схемой viridis.

6️⃣ Анимация графика (GIF)

anim = @animate for i in 1:100
    plot(x, sin.(x .+ i * 0.1), label="sin(x + $i)", color=:blue)
end

gif(anim, "sine_wave.gif", fps=10)

✅ Результат: Анимация синусоиды, сохраняемая как sine_wave.gif.

🎨 Выбор backend'ов

Plots.jl поддерживает разные бэкенды для отрисовки графиков. Можно переключать их так:

using Plots

gr()       # Использует GR (по умолчанию, быстрый)
pyplot()   # PyPlot (Matplotlib)
plotly()   # Plotly (интерактивные графики)
pgfplotsx() # LaTeX-совместимые графики

🔥 Сравнение с Matplotlib (Python)

Функция	Plots.jl (Julia)	Matplotlib (Python)
Производительность	🚀 Очень быстрая (GR)	🐢 Медленнее
API	🎯 Минималистичный	📜 Подробный, сложный
Интерактивность	🟢 Поддерживает Plotly	🟢 Да, через Jupyter
Гибкость	🔄 Легко менять backend	🔄 Поддержка разных backends
Анимация	🎥 Легко создается GIF	🎞️ `FuncAnimation`

📚 Полезные ресурсы

Выводы: 🎯

Plots.jl – это мощный инструмент визуализации в Julia, сочетающий простоту, скорость и гибкость. Он идеально подходит для научных вычислений, аналитики данных и интерактивных графиков! 🚀

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

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

Name		Name	Last commit message	Last commit date
Latest commit History 40 Commits
.github		.github
DataFrames		DataFrames
Deep-Learning		Deep-Learning
data		data
scripts		scripts
00.Motivation-Classifying-fruit.ipynb		00.Motivation-Classifying-fruit.ipynb
0300.Representing-data-with-models.ipynb		0300.Representing-data-with-models.ipynb
0500.Building-models.ipynb		0500.Building-models.ipynb
0700.Model-complexity.ipynb		0700.Model-complexity.ipynb
0900.What-is-learning.ipynb		0900.What-is-learning.ipynb
1100.Intro-to-neurons.ipynb		1100.Intro-to-neurons.ipynb
LICENSE		LICENSE
Project.toml		Project.toml
README.md		README.md
julia_ML.jpg		julia_ML.jpg

Uh oh!

License

Cartesian-School/Julia-for-Machine-Learning

Folders and files

Latest commit

History

Repository files navigation

Foundations-of-Machine-Learning

We're excited to be your gateway into machine learning. ML is a rapidly growing field that's buzzing with opportunity.

Julia слияние простоты и мощи в машинном обучении

Основные особенности Julia:

JIT-компиляция в Julia: Глубокий разбор 🚀

1️⃣ Что такое JIT-компиляция?

📌 Пример: Демонстрация JIT-компиляции

2️⃣ Почему Julia использует JIT?

3️⃣ Как JIT ускоряет код?

📌 Сравнение с интерпретацией

4️⃣ Визуализация процесса компиляции

📌 Генерация LLVM-кода

📌 Генерация машинного кода

5️⃣ Кэширование JIT-компиляции

📌 Проверка времени выполнения первой и второй итерации

6️⃣ Как избежать повторной компиляции?

📌 Пример: Почему JIT может работать медленнее

7️⃣ Оптимизация JIT-компиляции

📌 Используйте precompile()

📌 Компиляция пакетов

8️⃣ JIT-компиляция vs. AOT-компиляция

🎯 Итог

Типизация в Julia 🚀

1️⃣ Типизация в Julia: Динамическая vs. Статическая

📌 Динамическая типизация (гибкость, но медленнее)

📌 Статическая типизация (оптимизированная производительность)

📌 Использование параметризованных типов

2️⃣ Влияние типизации на использование памяти

📌 Пример использования памяти без оптимизации

📌 Как экономить память в Julia?

3️⃣ Пример оптимизации памяти с @allocated

📌 Пример без оптимизации (медленно)

4️⃣ Вывод типов в Julia (typeof, eltype)

5️⃣ Использование @code_warntype для оптимизации типов

📌 Пример неоптимального кода

💡 Итог

Supertype и Subtype в Julia 🚀

1️⃣ Что такое Supertype и Subtype?

2️⃣ Определение собственного супертипа

📌 Пример: Создание абстрактного типа Shape

📌 Проверка принадлежности к супертипу

3️⃣ Использование Supertype в функциях

4️⃣ Использование supertype()

5️⃣ Использование subtypes()

6️⃣ Различие abstract type и struct

📌 abstract type (абстрактные типы)

📌 struct (конкретные типы)

7️⃣ Пример с кастомной иерархией типов

🎯 Итог

Многопоточность в Julia 🚀

🔥 Основные особенности многопоточности в Julia

🛠 Настройка многопоточности

Способы задания количества потоков

🏎 Пример 1: Ускорение вычислений с @threads

🛡 Атомарные операции (без гонок данных)

Пример 2: Потокобезопасное увеличение счетчика

⚡ Пример 3: Параллельная обработка матрицы

🔄 Пример 4: Parallel map (Threads.@spawn)

🆚 Многопоточность vs. Многопроцессорность

🔗 Полезные ссылки

🎯 Итоги:

Множественная диспетчеризация в Julia 🚀

🔥 Как работает множественная диспетчеризация?

📌 Простой пример

🎯 Зачем нужна множественная диспетчеризация?

📌 Пример с арифметикой

🎭 Полиморфизм через абстрактные типы

⚡ Использование параметрических типов

🚀 Множественная диспетчеризация в сложных структурах

🔄 Перегрузка операторов через множественную диспетчеризацию

🎯 Когда использовать множественную диспетчеризацию?

💡 Итоги:

Machine Learning и библиотеки Julia для ML

📌 Используйте `precompile()`

3️⃣ Пример оптимизации памяти с `@allocated`

4️⃣ Вывод типов в Julia (`typeof`, `eltype`)

5️⃣ Использование `@code_warntype` для оптимизации типов

📌 Пример: Создание абстрактного типа `Shape`

4️⃣ Использование `supertype()`

5️⃣ Использование `subtypes()`

6️⃣ Различие `abstract type` и `struct`

📌 `abstract type` (абстрактные типы)

📌 `struct` (конкретные типы)

🏎 Пример 1: Ускорение вычислений с `@threads`

🔄 Пример 4: Parallel map (`Threads.@spawn`)

📌 Полносвязный слой (`Dense`)

📌 Сверточный слой (`Conv`)