🔤🔤🌹🌷 2️⃣

👨‍💻 Итак, друзья добрый вечер! Вот здесь мы начали разбирать Градиентный спуск, пост получился очень насыщенным, поэтому за 1 частью бегом туда ⬆️

0⃣🗂 Импортируем библиотеки (базово):

import numpy as np
import matplotlib.pyplot as plt

1⃣📇 Дальше сгенерим данные:

np.random.seed(42) # фиксируем "случайность", чтобы каждый раз при запуске были одинаковые данные
x = 2 * np.random.randn(100, 1) + 3
y = 4 + 3 * x + np.random.randn(100, 1)

2⃣📊 Инициализируем веса, задаем скорость обучения и количество эпох (это итерации обучения нашей модельки):

w = np.random.randn()
b = np.random.randn()

📊 Что касаемо скорости обучения? Хороший вопрос, скорость мы выставили небольшую — всего 0.01. Я вам кину в комменты картиночку, а пока что объясню:

⚙️ Помните я говорил про сравнение с вершиной горы? Дак вот, представьте, что гора максимально ровная и гладкая, если мы захотим спуститься, проблем не возникнет, одна низшая точка и будет глобальным минимумом. С какой бы точки горы мы не спустились, мы спустились бы к этому глобальному минимуму. Все что я сейчас сказал относится к
🔤🔤🔤✅🔤🌼 🔤🔤🔤🔤🌷🔤🔤🔤 выпуклой функции, (пример — MSE и другие несложные модели)

❓ Что же насчет невыпуклой функции?
🔤🔤🔤🔤🔤🔤🔤🔤✅🔤🌼 🔤🔤🔤🔤🌷🔤🔤🔤🔤Берем тот же пример с горой. На этот раз гора имеет холмы, ямы, долины и другие штуки, которые нам будут мешать спуститься. Ладно еще мы, прикиньте наша модель попадает в какой нибудь локальный минимум и наивно думает, что функция потерь минимальная) 🔜 Как вы уже поняли, невыпуклая функция в градиентном спуске это чисто для нейронок и всяких сложных прелестей ML. Для таких сложных моделей классического градиентного спуска не хватит, придется углубляться.

lr = 0.01
epochs = 1000

3⃣📊 Итак, куда-то нужно сохранять ошибки:

loss_history = []

4⃣📂 Теперь главный цикл, здесь будем обучать модель:

for epoch in range(epochs):
    y_pred = w * x + b
    loss = ((y - y_pred) ** 2).mean()
    loss_history.append(loss)

🧠 Разберем построчно:

🧑‍💻 Каждая итерация этого цикла — это одна эпоха. Проходим всем данным, делаем предсказания, считаем ошибку и корректируем параметры.

for epoch in range(epochs):

🧑‍💻 Уравнение прямой, которое мы уже рассматривали:

    y_pred = w * x + b

🧑‍💻 Дальше loss — это среднеквадратичное отклонение между предсказаниями y_pred и истинными y.

    loss = ((y - y_pred) ** 2).mean()

🧑‍💻 Создали несколько строчек назад пустой список 📎loss_history📎, так вот на каждой итерации будем добавлять туда текущую ошибку (Вывод в дальнейшем позволит оценить, как моделька изменялась):

    loss_history.append(loss)

5⃣📉 Теперь градиенты:

    dw = -2 * np.mean(x * (y - y_pred))
    db = -2 * np.mean(y - y_pred)

👨‍💻 Производную мы разбирали в прошлом посте, но там было немного попроще, пока что оценивайте код, будет 3 пост, где я разберу производные для данной модели:

🧑‍💻 x * (y - y_pred) — это разница между реальным и предсказанным (насколько модель ошиблась), Каждый входной x влияет на ошибку предсказания — если x большой и ошибка большая.

🧑‍💻 -2 это как раз из производной функции потерь (y - 2_pred)²

🧑‍💻 dw говорит, насколько и в какую сторону нужно изменить w, чтобы уменьшить ошибку

🧑‍💻 db — то же для b

6⃣ Обновляем параметры:

    w -= lr * dw
    b -= lr * db

📉 Двигаем w и b в сторону уменьшения ошибки, используя градиенты и скорость обучения

7⃣ Каждые 10 эпох мы будем выводить промежуточный результат:

    if epoch % 10 == 0:
        print(f"Эпоха {epoch}, Потеря: {loss:.4f}, w: {w:.4f}, b: {b:.4f}")

8⃣ 📁 Визуал:

plt.scatter(x, y, label="ТРУ данные")
plt.plot(x, w * x + b, color='red', label="Линия регрессии")
plt.plot(loss_history)
plt.xlabel("Эпоха")
plt.ylabel("Ошибка")
plt.title("Градиентный спуск: уменьшение ошибки")

👨‍💻🧑‍💻 Обновил навигацию по ML, читайте на здоровье:

📇 Machine learning

📊 Machine learning 2

📊 Machine learning 3

👨‍💻⚙️ Теперь Gemini 2.5 Pro теперь доступна бесплатно для всех пользователей с аккаунтом Google.

🧠 Ранее доступ к ней был ограничен подписчиками Gemini Advanced с тарифом Google One AI Premium за $19,99 в месяц. ​

Пользуемся здесь: http://gemini.google.com

🔤🔤🌹🌷 3️⃣

👨‍💻 Продолжаем разбирать градиентный спуск, часть 3 и на этот раз мы будем практиковаться. И нет, это не просто практика, одним кодом мы затронем все пройденное: трансформацию данных (Возьмем Z-core), MSE, MAE, R², Градиентный спуск, Линейная и Полиномиальная регрессии. Ну тогда давайте начинать:

0⃣🗂 Импортируем библиотеки:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error

1⃣📇 Дальше генерим данные:

np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

2⃣📊 Объявляем объект стандартизации и обучаем данные с учетом трансформирования (то есть, трансформация + обучение):

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

2⃣🤯 Инициализируем веса, задаем скорость обучения, количество эпох, объявляем функцию и m (пригодится для формулы — это количество примеров в выборке):

def linear_gradient_descent(X, y, lr=0.1, epoches = 1000):
    m = len(y)
    w = np.random.randn()
    b = np.random.randn()
    losses = []

3⃣⚙️ Теперь цикл градиентного спуска:

    for _ in range(epoches):
        y_pred = w * X.reshape(-1) + b  # Предсказания
        L = y_pred - y.reshape(-1)  # (Loss)

🧑‍💻 📎y_pred = w * X.reshape(-1) + b📎 — кароч это наша предсказанная линиия,

🧑‍💻 📎X.reshape(-1)📎 — превращает X в одномерный массив (это просто так удобно)

🧑‍💻 📎error = y_pred - y.reshape(-1)📎 — это типо ошибка, ну вы поняли

4⃣🛍 Считаем градиенты для обновления весов, обновляем веса и возвращаем вес и смещение (w, b):

        dw = (2/m) * np.sum(L * X.reshape(-1))  # Градиент для w
        db = (2/m) * np.sum(L)  # Градиент для b

        w -= lr * dw  # Обновляем w
        b -= lr * db  # Обновляем b
    
    return w, b

5⃣💳Обучаем линейную регрессию с градиентным спуском и получаем предсказания модели:

        w -= lr * dw  
        b -= lr * db  
        losses.append(mean_squared_error(y, y_pred))
    return w, b, losses

w, b, losses = linear_gradient_descent(X_scaled, y) # Обучение 
y_pred_lin = w * X_scaled + b # Наши результаты

6⃣✍️ Визуал:

print("Линейная регрессия")
print("w:", w)
print("b:", b)
print("MSE:", mean_squared_error(y, y_pred_lin))
print("MAE:", mean_absolute_error(y, y_pred_lin))
print("R²:", r2_score(y, y_pred_lin))

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


plt.subplot(1, 2, 1)
plt.scatter(X, y, color='black', label='Данные')
plt.plot(X, y_pred_lin, color='blue', label='Линейная регрессия')
plt.xlabel("X")
plt.ylabel("y")
plt.legend()
plt.title("Линейная регрессия")


plt.subplot(1, 2, 2)
plt.plot(range(len(losses)), losses, color='red', label="MSE")
plt.xlabel("Итерации")
plt.ylabel("Ошибка (MSE)")
plt.legend()
plt.title("График обучения градиентного спуска")

plt.show()

📱Что насчет вывода?

🧑‍💻 w: 1.639897299913427

🧑‍💻b: 6.820004100101897

🧑‍💻MSE: 0.8065845639670531

🧑‍💻MAE: 0.7010426719637758

🧑‍💻R²: 0.7692735413614223

⬇️ Графики в комментах ⬇️

⚙️Также стоит упомянуть сами формулы и реализацию градиентного спуска, о нем речь все-таки... В общем, смотрите:

🟰 MSE = 1/m * ∑ * (y_pred - y)² 🟰при этом, y_pred = wX + b 🟰

🟰 ∂L/ ∂w = 2/m * ∑ * (y_pred - y) * X 🟰 Касаемо частных производных (это мы градиенты считали) 🟰

🟰 ∂L/ ∂b = 2/m * ∑ * (y_pred - y) 🟰

🟰 w = w - α * ∂L/ ∂w 🟰где α - learning rate (скорость обучения)

🟰 b = b - α * ∂L/ ∂b 🟰

🔗 Код корректирует эти шаги (корректирует w и b), пока ошибка не уменьшится

🧑‍💻 Подписичники, скоро балдейший пост

🔤🔤🌹🌷 4️⃣

👨‍💻 Друзья, ку! Разбираем интересное задание, закину сразу условие и потихоньку буду объяснять:

⚙️ В коде ниже (в следующем посте будет) сформирована выборка x, y из случайных значений в соответствии с формулой:🟰 yᵢ = w₀ + w₁ * xᵢ + ϵᵢ 🟰 i = 1, 2, ..., n 🟰. где w₀, w₁ — весовые коэффициенты, xᵢ — аргумент, ϵᵢ — случайная величина с нулевым мат. ожиданием и некоторой постоянной дисперсией.

🧑‍💻 Значения yᵢ прогнозируются с помощью следующей параметрической модели:

🟰 a(x, w) = w₀ + w₁ * x 🟰Параметры: w₀ = 0.5, w₁ = -0.3

🧑‍💻 Итак, а в чем смысл задания? Используя квадратическую функцию потерь, которую мы изучили ранее (если че вот она 🟰 loss(a, y₁) = (a(x₁, w) - y₁)² 🟰), нам нужно вычислить средний эмпирический риск Q(a, X) по формуле:

🟰 Q(a, X) = 1/n * ∑ loss (a, yᵢ) 🟰

‼️👨‍💻 Понимаю, что звучит это все дико, но вы же знаете, я просто так вам ничего не оставляю, потихоньку мы это все разберем. Пока что держите некоторые пояснения, а завтра продолжим 📇

🧑‍💻 w₀, w₁ — коэффициенты модели, веса (уже заданы фиксированными числами, смотрите выше)

🧑‍💻 xᵢ — аргумент, значения которого лежат в диапазоне [-1; 1] с шагом 0.1.

🧑‍💻 ϵ₁ — случайный шум (ошибка измерения), который подчиняется нормальному распределению с нулевым математическим ожиданием (то есть, в среднем шум = 0) и фиксированной дисперсией.

📱 Шум — это непредсказуемая ошибка, которая влияет на каждое измерение.

➿➿➿➿➿➿➿➿➿➿

📱 Математическое ожидание (mean, ожидание среднего значения
— это просто среднее значение всех возможных шумов.

➿➿➿➿➿➿➿➿➿➿

📱 Дисперсия показывает, насколько сильно значения разбросаны около среднего. ⚙️ Если дисперсия маленькая (например, 0.01):

🔵Почти все значения шума близки к 0

🔵Шум почти не влияет на данные

Вывод: "Чем больше дисперсия, тем сильнее скачет шум"

➿➿➿➿➿➿➿➿➿➿

🔤🔤🌹🌷 5️⃣

👨‍💻 Итак, продолжаем:

⚙️ Как я уже говорил в прошлом посте, мы имеем код, нам лишь остается его дописать. Но проблема в том. что есть много моментов, с которыми мы еще не работали, вот их и попытаемся понять. Итак, мы имеем такой код:

import numpy as np

np.random.seed(0) # псевдослучайные числа образуют одну и ту же последовательность (при каждом запуске)
x = np.arange(-1.0, 1.0, 0.1) # аргумент [-1; 1] с шагом 0,1

size_train = len(x)  # размер выборки
w = [0.5, -0.3]  # коэффициенты модели
model_a = lambda m_x, m_w: (m_w[1] * m_x + m_w[0])  # модель
loss = lambda ax, y: (ax - y) ** 2 # квадратическая функция потерь

y = model_a(x, w) + np.random.normal(0, 0.1, len(x)) # целевые значения

‼️ Главный вопрос в том, что мы хотим? Мы уже имеем простую модельку 🟰 y = w₀ + w₁ * x 🟰. Нам нужно найти эмпирический риск с помощью MSE.

🧠 Эмпирический риск — это средняя величина ошибки алгоритма на обучающей выборке.

🟰 Q(a, X) = 1/n * ∑ loss(a, yᵢ) 🟰 — Формула среднего эмпирического риска.

🟰 loss(a, yᵢ) = (a(xᵢ , w) − yᵢ)² 🟰— Квадратическая функция потерь.

🟰 a(x,w) = w₀ + w₁ ⋅ x 🟰 — Параметрическая модель с параметрами w₀ = 0.5 w₁ = -0.3

🟰 yᵢ = w₀ + w₁ * xᵢ + ϵᵢ 🟰 i = 1, 2, ..., n 🟰

➿➿➿➿➿➿➿➿➿➿
🧑‍💻 Касаемо первых строк ничего нового. просто импорт и просто установка 🟰 np.random.seed(0) 🟰для генератора случайных чисел (одни и те же значения каждый раз).
➿➿➿➿➿➿➿➿➿➿
🧑‍💻🟰 x = np.arange(-1.0, 1.0, 0.1) 🟰 — Создаём массив x значений от -1.0 до (не включая) 1.0 с шагом 0.1, получаем [-1.0, -0.9, -0.8, ..., 0.9] и так 20 значений
➿➿➿➿➿➿➿➿➿➿
🧑‍💻 🟰 size_train = len(x) 🟰 У нас это значение равно 20
➿➿➿➿➿➿➿➿➿➿
🧑‍💻 🟰 w = [0.5, -0.3] 🟰 — веса модели (коэффициенты линейного уравнения), 🔗 w[0] = 0.5 — это смещение (bias, свободный член), 🔗 w[1] = -0.3 — это наклон (slope) — определяет, вверх или вниз идёт прямая. ➡️ Получаем модель 🟰 y = 0.5 - 0.3x 🟰
➿➿➿➿➿➿➿➿➿➿
🧑‍💻‼️ Теперь очень важно, 🟰model_a = lambda m_x, m_w: (m_w[1] * m_x + m_w[0]) 🟰— Это лямбда-функция, то есть функция в одну строку, она строит модель линейной регрессии (нашу прямую на плоскости) — 🟰 a(x,w) = w₀ + w₁ ⋅ x 🟰

🔵m_x — массив аргументов (это наш x)

🔵m_w — массив весов (в нашем случае w = [0.5, -0.3])

⚙️ "Берем x, умножаем на второй коэффициент w (то есть наклон), и прибавляем первый коэффициент (смещение)"

❓Как это работает? Это не наш случай, данные немного отличаются, поэтому показываю на примере:

m_x = np.array([1, 2, 3])  
m_w = [0.5, -0.3]

# Если мы подставим:

model_a(m_x, m_w) → (-0.3 * m_x + 0.5)

# Получаем:

y = -0.3 * np.array([1, 2, 3]) + 0.5

# Сами вычисления:

-0.3 * [1, 2, 3] = [-0.3, -0.6, -0.9]
[-0.3, -0.6, -0.9] + 0.5 = [0.2, -0.1, -0.4]

🔤🔤🌹🌷 6️⃣

➿➿➿➿➿➿➿➿➿➿
🧑‍💻 Теперь функция потерь: 🟰 loss = lambda ax, y: (ax - y) ** 2 🟰

🔵 ax — это предсказания модели: a(x, w), как вы помните, оно равно 🟰 a(x,w) = w₀ + w₁ ⋅ x 🟰

🔵 y — это реальные значения

⚙️ Квадрат разницы между y_pred и y будет равен:

🟰 loss(a, yᵢ) = (a(xᵢ , w) − yᵢ)² 🟰
➿➿➿➿➿➿➿➿➿➿
🧑‍💻 🟰 y = model_a(x, w) + np.random.normal(0, 0.1, len(x)) 🟰

🔵 🟰 model_a(x, w) 🟰 — предсказываем идеальные значения, которые дала бы наша линейная модель.

🔵 np.random.normal(0, 0.1, len(x)) 🟰 — создаём шум:

➿ распределение: нормальное (гауссовское)

➿ среднее = 0 → в среднем шум не искажает

➿ стандартное отклонение = 0.1 → поэтому шум у нас слабый

➿ длина = столько же, сколько в x
➿➿➿➿➿➿➿➿➿➿
🧑‍💻 🟰 Q = loss(model_a(x, w), y).mean() 🟰

🔵 🟰 model_a(x, w) 🟰 — снова предсказываем значения на основе модели

🔵 🟰 loss(...) 🟰 — получаем массив ошибок (в квадрате) между предсказанием и y.

🔵 🟰 .mean() 🟰 — берём среднее значение всех этих ошибок

🔤🔤🔤🔤🌹🔤🔤🔤🪷 🔤🔤🔤🔤🔤🔤🌷

Q(y_pred, yᵢ)) = 1/n * ∑ loss(y_pred, yᵢ) — вот мы и получили эмпирический риск

🔤🔤🌹🌷 7️⃣

👨‍💻 Итак, друзья, вы уже увидели этот график в комментариях к прошлому посту (надеюсь, хотя код вывода графика не подразумевает. Так вот сейчас мы это и исправим..
➿➿➿➿➿➿➿➿➿➿
⚙️ Код мы сильно изменять не будет, достаточно добавить несколько строчек:

🧑‍💻 Добавим библиотеку seaborn:

📱 Seaborn — библиотека для создания статистических графиков на языке Python. Она построена на основе библиотеки Matplotlib и тесно интегрирована со структурами данных из Pandas.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

➿➿➿➿➿➿➿➿➿➿
🧑‍💻 Теперь изменим немного последние строки и сам вывод, все остальное остается неизменным:

y_pred = model_a(x, w)
Q = loss(y_pred, y).mean()


sns.lineplot(x = x, y = y_pred, color = 'red')
sns.scatterplot(x = x, y = y)
plt.show()

➿➿➿➿➿➿➿➿➿➿
‼️🧑‍💻 Теперь хотел поговорить немного про логику самого кода:

📇 Если возвращаться к ламбде, то вот эта строка: 🟰 model_a = lambda m_x, m_w: (m_w[1] * m_x + m_w[0]) 🟰— может выглядеть и вот так:

def model_a(m_x, m_w):
    return m_w[1] * m_x + m_w[0]

🔵 И когда мы вызываем 🟰 model_a(x, w), 🟰 мы передаем

➿ m_x = x
➿ m_w = w

➿➿➿➿➿➿➿➿➿➿
🧑‍💻 Аналогично будет и со 2 функцией:

def loss(y_pred, y):
    return (y_pred - y) ** 2

⚙️ y мы получаем со строки 🟰y = model_a(x, w) + np.random.normal(0, 0.1, len(x))🟰

⚙️ y_pred — предсказанные значения (из model_a)

🧑‍💻 Весь код:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

np.random.seed(0)

x = np.arange(-1.0, 1.0, 0.1)

size_train = len(x)
w = [0.5, -0.3]
# model_a = lambda m_x, m_w: (m_w[1] * m_x + m_w[0])

def model_a(m_x, m_w):
    return m_w[1] * m_x + m_w[0]

# loss = lambda y_pred, y: (y_pred - y) ** 2

def loss(y_pred, y):
    return (y_pred - y) ** 2

y = model_a(x, w) + np.random.normal(0, 0.1, len(x))

y_pred = model_a(x, w)
Q = loss(y_pred, y).mean()

sns.lineplot(x = x, y = y_pred, color = 'red')
sns.scatterplot(x = x, y = y)
plt.show()

👨‍💻 Итак, новый пост, так что возрадуемся! Я внатуре чета приболел нехило, но щас чувствую себя получше. Разбираем новое задание:

🌷🔤🔤🔤
➿➿➿➿➿➿➿➿➿➿
0⃣‼️ Нам нужно вычислить коэффициенты w модели: a(x,w) = w₀ + w₁ ⋅ x. Также нам нужно в коде сформировать обучающую выборку X в виде матрицы: 📎 1 x₁ 📎
📎 1 x₂ 📎
📎 1 x₃ 📎
и вычислить коэффициенты w, используя Q (средний эмпирический риск при MSE).

🔤🔤🌹🔤🔤🪷🔤🔤
➿➿➿➿➿➿➿➿➿➿
1⃣:

🟰Q(a, X) = 1/n * (X * w - Y)²🟰— Эмпирический риск при квадратической функции потерь

🟰∂Q(a, X)/ ∂w = 2/n * Xᵀ (X * w - Y) = 0🟰— Дифференцируем выражение по вектору w

🟰w = (Xᵀ * X)⁻¹ * Xᵀ * Y🟰— Находим вектор по w

2⃣‼️ Что важно понимать? Мы хотим найти уравнение прямой: y = w0 + w1 * x, так вот, в матричном виде это будет выглядеть вот так: y = X @ w

3⃣⚙️ Теперь делаем все с примером, возьмем рандомные значения X и Y:

X = [[1, 1],
[1, 2],
[1, 3]]

Y = [[2.1], — Это наши True значения
[2.9],
[3.8]]

4⃣🛍 Теперь считаем по формуле 🟰w = (Xᵀ * X)⁻¹ * Xᵀ * Y🟰:

4⃣.1⃣ Считаем Xᵀ X:

Xᵀ = [[1,1,1],[1,2,3]]

Xᵀ @ X =
[[1, 1, 1], [[1, 1],
[1, 2, 3]] x [1, 2],
[1, 3]]

= [[1*1 + 1*1 + 1*1, 1*1 + 1*2 + 1*3],
[1*1 + 2*1 + 3*1, 1*1 + 2*2 + 3*3]]

= [[3, 6],
[6, 14]]

4⃣.2⃣ Считаем Xᵀ Y:

Xᵀ Y = [[1,1,1],[[2.1],[1,2,3]]x[2.9],[3.8]]=[[1∗2.1+1∗2.9+1∗3.8],[1∗2.1+2∗2.9+3∗3.8]]=[[8.8],[19.3]]

4⃣.3⃣ Теперь собираем формулу 🟰w = (Xᵀ * X)⁻ ¹ * Xᵀ * Y🟰:

🟰 Xᵀ X = [[3, 6], [6, 14]] 🟰

🟰 Xᵀ Y = [[8.8], [19.3]] 🟰

4⃣.4⃣ Теперь ищем обратную 2x2 матрицу, опять же, все по формулам!

🟰 [[a,b], [c,d]]⁻ ¹ =1 / (ad−bc) ∗ [[d,−b], [−c,a]] 🟰

🔤🔤🔤 Таак, надеюсь вам все понятно, а если нет, то комменты открыты, спрашивайте на здоровье.

‼️ Чтобы найти обратную матрицу 2×2, нам нужно вычислить детерминант, вот формула:

🟰det = ad − bc🟰

🟰det = 3 ⋅ 14 − 6 ⋅ 6 = 42 − 36 = 6 🟰— Подставляем и получаем 6 (наш знаменатель )

🟰 (XᵀX)⁻ ¹ = (1/6) * [[14, -6],
[-6, 3]] 🟰

4⃣.5⃣ Умножаем:

📊 w = (1/6) * [[14, -6],
[-6, 3]] @ [[8.8],
[19.3]] = [[7.4],
[5.1]]


🔗 Теперь получаем модель 🟰y ≈ 1.233 + 0.85 ∗ x🟰

🧑‍💻 w₀ = 1.233 — смещение (bias)

🧑‍💻 w₁ = 0.85 — коэффициент наклона

🌹🔤🔤🔤🪷🌷

Завтра +- все это мы интерпретируем в виде кода, там полегче будет намного. Даже эта писанина сверху — это не сложно, просто попытайтесь вникнуть в то, что я написал.