#教え
Видео 8/22 1:45:00 -> end

ООП - Инкапсуляция
Объединение логики и данных для использования в одной упаковке.

Модификаторы доступа - в python это всеобщая договоренность, а не строгая механика
def public - доступно везде
def _protected - воступно везде но семантически указано что должно использоваться
внутри класса родителя и наследника
def private - поле не доступно извне родительского класса

при этом к private полю можно получить доступ если дописать название родительского класса с нижним
почеркиванием _ParentClass__private_field (опасная практика, по сути взлом)

class User:
    def __init(self):
        self.name = "User"

    # зададим приватный метод
    def __private_greet(self):
        return f"Hello, {self.name}!"

    # зададим публичный интерфейс для этого метода
    def greet(self):
        return self.__private_greet()

class John(User):
    # попробуем переопределить приватный метод родителя
    # на этот раз доберемся до оригинального метода обойдя name mangling 
    def _User__private_greet(self):
        return f"Hello, John!"

# метод изменился
John().greet() # Hello, John!

Осуждаем?

#hw lesson 6

Матрицы
Каждый раз возвращаясь хотел пропустить, зачем они мне нужны. Спойлер, в opencv (computer vision) каждая картинка представлена матрицей. Хочу знать о них все.

import random
from functools import reduce
from pprint import pprint


# Создать матрицу случайных чисел от a до b, размерность матрицы n*m
def generate_matrix(a, b, n, m):
    return [
        [random.randint(a, b) for _ in range(n)]
        for _ in range(m)
    ]


# Найти максимальный элемент матрицы.

def get_matrix_max_value(matrix):
    return max([max(row) for row in matrix])


# Найти минимальный элемент матрицы.

def get_matrix_min_value(matrix):
    return min([min(row) for row in matrix])


# Найти сумму всех элементов матрицы.
def get_matrix_sum(matrix):
    return sum(reduce(lambda s, x: s + x, matrix))


# Найти индекс ряда с максимальной суммой элементов.

def get_max_sum_row_index(matrix):
    # джус от gpt (҂◡̀_◡́)ᕤ
    return max(range(len(matrix)), key=lambda i: sum(matrix[i]))


# Найти индекс колонки с максимальной суммой элементов.
def get_max_sum_column_index(matrix):
    # (҂◡̀_◡́)ᕤ
    return max(range(len(matrix[0])), key=lambda i: sum([matrix[col_i][i] for col_i in range(len(matrix))]))


# Найти индекс ряда с минимальной суммой элементов
def get_min_sum_row_index(matrix):
    return min(range(len(matrix)), key=lambda i: sum(matrix[i]))


# Найти индекс колонки с минимальной суммой элементов.
def get_min_sum_column_index(matrix):
    return min(range(len(matrix[0])), key=lambda i: sum([matrix[col_i][i] for col_i in range(len(matrix))]))


# Обнулить все элементы выше главной диагонали.
def reset_above_main_diag(matrix):
    for i in range(len(matrix)):
        matrix[i] = matrix[i][:i + 1] + [0 for el_i in range(1, len(matrix[i])) if el_i > i]
    return matrix


# Обнулить все элементы ниже главной диагонали.
def reset_below_main_diag(matrix):
    for i in range(len(matrix)):
        matrix[i] = [0 for _ in range(i)] + matrix[i][i:]
    return matrix


# Создать матрицу равную сумме matrix_a и matrix_b.
def get_matrix_sum(matrix_a, matrix_b):
    return [
        [matrix_a[row_i][i] + matrix_b[row_i][i]
         for i in range(len(matrix_a[row_i]))
         ] for row_i in range(len(matrix_a))
    ]

# Создать матрицу равную разности matrix_a и matrix_b.
def get_matrix_difference(matrix_a, matrix_b):
    return [
        [matrix_a[row_i][i] - matrix_b[row_i][i]
         for i in range(len(matrix_a[row_i]))
         ] for row_i in range(len(matrix_a))
    ]


# Создать новую матрицу равную matrix_a умноженной на g. g вводится с
# клавиатура
def multyply_matrix_from_input():
    n = 3
    while (enter_num := int(input('enter num'))) != 'stop':
        matrix = generate_matrix(1, 10, n, n)
        print(matrix)
        print([list(map(lambda x: x * enter_num, row)) for row in matrix])

#hw lesson 7

Укрепление работы с функциями.

# 1. inches to centimeters (дюймы - ширина большого пальца)
def convert_inches_to_centimeters(value: int):
    return value * 2.54


# 2. Centimeters to inches
def convert_centimeters_to_inches(value: int):
    if value == 0:
        return value
    return value / 2.54


# 3. Miles to kilometers (мили с древнего рима 1482 м)
def convert_miles_to_kilometers(value: int):
    return value * 1.482


# 4. Kilometers to miles
def convert_kilometers_to_miles(value: int):
    if value == 0:
        return value
    return value / 1.482


# 5. Pounds to Kilograms
def convert_pounds_to_kilograms(value: int):
    return value * 16.3805


# 6. Kilograms to Pounds
def convert_kilograms_to_pounds(value: int):
    if value == 0:
        return value
    return value / 16.3805


# 7. Ounces to grams
def convert_ounces_to_grams(value: int):
    return value * 28.35


# 8. Grams to Ounces
def convert_grams_to_ounces(value: int):
    if value == 0:
        return value
    return value / 28.35


# 9. Gallons to Liters
def convert_gallons_to_liters(value: int):
    return value * 4.5


# 10. Liters to Gallons
def convert_liters_to_gallons(value: int):
    if value == 0:
        return value
    return value / 4.5


# 11. Pints to Liters
def convert_pints_to_liters(value: int):
    return value * 0.473


# 12. Liters to pints
def convert_liters_to_pints(value: int):
    if value == 0:
        return value
    return value / 0.473

Тесты

from homework.tasks_7 import (
    convert_inches_to_centimeters,
    convert_centimeters_to_inches,
    convert_miles_to_kilometers,
    convert_kilometers_to_miles,
    convert_pounds_to_kilograms,
    convert_kilograms_to_pounds,
    convert_ounces_to_grams,
    convert_grams_to_ounces,
    convert_gallons_to_liters,
    convert_liters_to_gallons,
    convert_pints_to_liters,
    convert_liters_to_pints
)
import pytest
from decimal import Decimal


# Тесты с использованием @pytest.mark.parametrize
@pytest.mark.parametrize(
    "enter_value, expected_value",
    [
        (1, 2.54),
        (0, 0),
        (-1, -2.54)
    ]
)
def test_convert_inches_to_centimeters(enter_value, expected_value):
    assert convert_inches_to_centimeters(enter_value) == pytest.approx(expected_value)


@pytest.mark.parametrize(
    "enter_value, expected_value",
    [
        (2.54, 1),
        (0, 0),
        (-2.54, -1)
    ]
)
def test_convert_centimeters_to_inches(enter_value, expected_value):
    assert convert_centimeters_to_inches(enter_value) == pytest.approx(expected_value)


@pytest.mark.parametrize(
    "enter_value, expected_value",
    [
        (1, 1.60934),
        (0, 0),
        (-1, -1.60934)
    ]
)
def test_convert_miles_to_kilometers(enter_value, expected_value):
    assert convert_miles_to_kilometers(enter_value) == pytest.approx(expected_value)


@pytest.mark.parametrize(
    "enter_value, expected_value",
    [
        (1.60934, 1),
        (0, 0),
        (-1.60934, -1)
    ]
)
def test_convert_kilometers_to_miles(enter_value, expected_value):
    assert convert_kilometers_to_miles(enter_value) == pytest.approx(expected_value)


@pytest.mark.parametrize(
    "enter_value, expected_value",
    [
        (1, 0.453592),
        (0, 0),
        (-1, -0.453592)
    ]
)
def test_convert_pounds_to_kilograms(enter_value, expected_value):
    assert convert_pounds_to_kilograms(enter_value) == pytest.approx(expected_value)


@pytest.mark.parametrize(
    "enter_value, expected_value",
    [
        (0.453592, 1),
        (0, 0),
        (-0.453592, -1)
    ]
)
def test_convert_kilograms_to_pounds(enter_value, expected_value):
    assert convert_kilograms_to_pounds(enter_value) == pytest.approx(expected_value)

keep calm, concentrate, fight

#hw lesson 8
Math

# Описать функцию fact2( n ), вычисляющую двойной факториал :n!! =
# 1·3·5·...·n, если n — нечетное; n!! = 2·4·6·...·n, если n — четное (n > 0 —
# параметр целого типа. С помощью этой функции найти двойные
# факториалы пяти данных целых чисел [01-11.2-Proc35]
def fact2(n):
    if n < 3:
        return n
    return reduce(lambda x, a: a * x, [num for num in range(2 - (n & 1), n + 1, 2)])


# Даны три слова. Выяснить, является ли хоть одно из них палиндромом
# ("перевертышем"), т. е. таким, которое читается одинаково слева направо и
# справа налево. (Определить функцию, позволяющую распознавать слова
# палиндромы.)[03-10.32] (просто реализовал функцию палиндром)
def is_palindrome(word: str) -> bool:
    if len(word) < 1:
        return False
    if word == word[::-1]:
        return True
    return False


# Описать функцию Sin1( x , ε ) вещественного типа (параметры x , ε —
# вещественные, ε > 0), находящую приближенное значение функции sin( x ):
# sin( x ) = x – x ^3 /(3!) + x^ 5 /(5!) – ... + (–1) ^ n · x^( 2·n+1) /((2· n +1)!) + ... .
# В сумме учитывать все слагаемые, модуль которых больше ε . С помощью
# Sin1 найти приближенное значение синуса для данного x при шести данных
# ε . [01-11.3-Proc41]

def sin1(x, epsilon):
    s = x
    n = 1
    fact_collector = 1
    while True:
        fact_collector = fact_collector * (2 * n) * (2 * n + 1)
        # сначала написал -1 ** 2, но в python - перед единицей это унарный оператор
        # и соответственно степень имеет высший приоритет -_-
        symb = (-1) ** n
        num_path = (x ** (2 * n + 1))
        temp_s = symb * num_path / fact_collector
        if abs(temp_s) < epsilon:
            break
        s += temp_s
        n += 1

    return s

Тесты

@pytest.mark.parametrize(
    "enter_value, expected_value",
    [
        (1, 1),
        (0, 0),
        (9, 945),
        (6, 48),
    ]
)
def test_fact2(enter_value, expected_value):
    assert fact2(enter_value) == pytest.approx(expected_value)


# Здесь предполагается, что функция Sin1 уже определена

@pytest.mark.parametrize(
    "enter_value, expected_value",
    [
        ('sor', False),
        ('', False),
        ('sos', True),
        ('poop', True),
    ]
)
def test_is_palindrome(enter_value, expected_value):
    assert is_palindrome(enter_value) == pytest.approx(expected_value)


@pytest.mark.parametrize(
    "x, epsilon, expected_approx",
    [
        (0, 0.1, 0),  # sin(0) = 0
        (math.pi / 6, 0.01, 0.5),  # sin(π/6) ≈ 0.5
        (math.pi / 4, 0.01, math.sqrt(2) / 2),  # sin(π/4) ≈ √2/2
        (math.pi / 2, 0.01, 1),  # sin(π/2) = 1
        (math.pi, 0.01, 0),  # sin(π) = 0
        (3 * math.pi / 2, 0.01, -1),  # sin(3π/2) = -1
        (2 * math.pi, 0.01, 0),  # sin(2π) = 0
        # Добавьте дополнительные тестовые случаи по вашему выбору
    ]
)
def test_sin1(x, epsilon, expected_approx):
    assert sin1(x, epsilon) == pytest.approx(expected_approx, rel=epsilon)

#cv Сверточные нейронные сети СНС (Convolutional Neural Networks CNN)

Facebook автоматом проставляет теги, google - поиск среди фото юзера, амазон генерирует рекомендации товаров, pintrest и instagram для поиска.

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

Что конкретно делают СНС? Берётся изображение, пропускается через серию свёрточных, нелинейных слоев, слоев объединения и полносвязных слоёв, и генерируется вывод.

Для нас картинка это разные цвета из которых мы формируем образы, машина видит это как матрицу из чисел.
Вводное изображение — это матрица 32 х 32 х 3 (32 на 32 квадрат из чисел, а x 3 это RGB, то есть в каждом числе находятся 3 показателя цвета)

#cv Первый cлой — математическая часть.

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

В терминах компьютерного обучения фонарик это фильтр (нейрон или ядро), а области, на которые он светит - рецептивные поля (поля восприятия).

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

Выход для I фильра - карта свойств.

#cv На прикрепленном рисунке видны примеры фактических визуализаций фильтров первого свёрточного слоя обученной сети.

#value изображения выше — из Стэнфордского курса 231N, который преподают Андрей Карпатый и Джастин Джонсон (Andrej Karpathy and Justin Johnson).

#cv Классическая архитектура СНС
Input: Входные данные (например, изображения).

Conv: Сверточный слой, свертка(convolution) - извлекающий признаки (features) с помощью фильтров.

ReLU: Функция активации, заменяющая отрицательные значения на ноль. Уменьшает эффект затухающего градиента.

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

Pool: Слой подвыборки, уменьшающий размерность данных (например, Max Pooling). Это помогает уменьшить вычислительные затраты и контролировать переобучение.

Fully Connected: Полносвязный слой, соединяющий все нейроны предыдущего слоя для окончательной классификации.

#cv Полносвязные слои

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

# грубая вызуализация n пространственого вектора 
       ---> (0.2)
      /
(0.8)            ---> (0.5)
      \
       ---> (0.3)

Выходом является n пространственный вектор (суперсложный термин, грубо говоря можно представить несколько векторов исходящих из одной точки, (входных даных), а на концах возможные классы по типу птицы, собаки, рыбы и тд). Каждый вектор в результате несет проценты вероятность исхода на этом векторе. Есть хвост (птица, рыба, собака выше процент), есть ноги(выше птица и собака), есть крылья(выше птица).

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

#cv Обучение нейросети

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

Родители и учителя показывают нам разные картинки и изображения и присваивают им соответствующие ярлыки. Та же идея показа картинки и присваивания ярлыка используется в обучающем процессе, который проходит СНС.

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

Его можно разделить на 4 блока:
- прямое распространение
- функцию потери
- обратное распространение
- обновление веса

#cv Прямое распространение

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

 [.1 .1 .1 .1 .1 .1 .1 .1 .1 .1]

(значения n-вектора) не дается предпочтения определенному числу

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

Допустим, первое обучающее изображение — это цифра 3.
Ярлыком изображения будет

[0 0 0 1 0 0 0 0 0 0]

Функция потери может быть выражена по-разному, но часто используется СКО (среднеквадратическая ошибка):
1/2 умножить на (реальность — предсказание) в квадрате

#cv Реакция нейронов зрительной коры человека на разные типы линий

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

https://www.youtube.com/watch?v=Cw5PKV9Rj3o&ab_channel=GIVN2SIN

#cv функция потери

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

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

Веса нейронной сети (очевидно их больше, чем 2, но тут пример упрощен) это независимые переменные, а зависимая переменная — это потеря. Задача снизить потерю. Нам нужно приблизиться к самой нижней точке чашеподобного объекта. Для этого требуется найти производную потери (в данном графике — рассчитать угловой коэффициент в каждом направлении) с учётом весов).
Это эквивалент dL/dW, где W — веса определенного слоя.

#ml Основы. Методы обучения нейронных сетей.

1. Обучение с учителем (supervised learning) - при обучении нейронная сеть получает данные и их значение. Чтобы описать содержимое датасета, его просматривают вручную и размечают. Это делает человек или группа — тот самый условный учитель.

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

2. Обучение без учителя (unsupervised learning) - нейронная сеть получает на вход неразмеченные данные и старается сама найти в них общие признаки и закономерности.

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

Используются для:
- Кластерного анализа (разделение больших массивов данных на группы)
- Выявления аномалий (например, обучение нейронной сети сначала на "нормальных" данных, чтобы она могла обнаруживать выбросы при работе)
- Нахождения ассоциаций (определение критериев сходства между объектами и установление связей)

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

3. Машинное обучение с подкреплением - суть метода заключается в том, что нейронная сеть получает входные данные и обрабатывает их случайным образом. После этого результаты работы оцениваются по определенным критериям. Нейронная сеть видит эти критерии и в следующий раз обрабатывает данные так, чтобы им соответствовать.

Используется для:
- Обучения машин механическим манипуляциям
- Управления транспортом
- Работы в техподдержке

Минусы:
❌ Требуется очень много времени.
❌ Необходимо множество реальных примеров.

#ml Основы. Выборка.

Обучающая выборка - данные для разработки модели

«Валидационная выборка» — данные для подбора оптимального набора гиперпараметров.

«Тестовая выборка» — данные позволяещие протестировать модель и являющиеся контрольным.

#ml Метрики моделей. Accuracy

отвечает на вопрос: как часто модель делает правильное предположение.

Accuracy = correct predictions/ all predictions

Проблема accuracy в случаях, где метки класса будут выявляться редко, например на рентген снимках. Представим что из выборки 100 снимков только 3 будут раковыми. Если обучить модель так, чтобы она рандомно ставила 97 процентов снимков без рака, тогда даже если она пропустила все 3 раковых снимка ее accuracy будет 0.97

accuracy - полезная метрика, когда вы имеете дело со сбалансированными классами и заботитесь об общей "правильности" модели, а не о способности предсказывать конкретный класс.

Accuracy легко объяснить и передать.

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