Логово Комара

Реализация нейронной сети для распознавания объектов на фотографиях 📷 Часть 1. Распознавание образов может выполняться с использованием либо традиционных методов обработки изображений, либо современных сетей глубокого обучения.

import numpy
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, BatchNormalization, Activation
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.constraints import maxnorm
from keras.utils import np_utils
from keras.datasets import cifar10
seed = 21

# loading in the data
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

Если значения входных данных находятся в слишком широком диапазоне, это может отрицательно повлиять на работу сети. В нашем случае входными значениями являются пиксели в изображении, которые имеют значение от 0 до 255.

# normalize the inputs from 0-255 to between 0 and 1 by dividing by 255
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train = X_train / 255.0
X_test = X_test / 255.0

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

# one hot encode outputs
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
class_num = y_test.shape[1]

Квантование нейронных сетей. Что это и зачем нужно 📑 Квантование моделей — метод, повышающий скорость вычислений за счет улучшения переносимости и уменьшения размера модели, — имеет решающее значение для решения этих проблем. Он помогает развертывать модели для более быстрых и эффективных решений периферийного ИИ. В последнее время некоторые исследователи изучают квантование больших языковых моделей (LLM) для снижения стоимости развертывания. Одним из основных факторов, отличающих квантование LLM, является то, что LLM с их огромными параметрами слишком дороги для обучения. Как происходит квантование? Квантование — это метод, который включает в себя отображение высокоточных значений в низкоточные дискретные значения. Этот процесс снижает требования к памяти и вычислительным ресурсам модели, делая ее более эффективной для развертывания на устройствах с ограниченными ресурсами Рисунок: Игрушечный пример 4-битного равномерного квантования с различными масштабными коэффициентами α.

Последний шаг- запуск инференса и тестирование модели Посмотрим на инференс модели на текстовом примере. Финальный классификатор получаем с помощью pipeline из библиотеки transformers.

from transformers import pipeline

# load model from huggingface.co/models using our repository id
classifier = pipeline("sentiment-analysis", model=repository_id, tokenizer=repository_id, device=0)

sample = "I have been waiting longer than expected for my bank card, could you provide information on when it will arrive?"


pred = classifier(sample)
print(pred)
# [{'label': 'card_arrival', 'score': 0.9903606176376343}]

Таким образом, мы сделали обучение модели классификации текста на наборе данных BANKING77.

Реализация нейронной сети с помощью hugging face. Часть 2. Последний шаг - определить гиперпараметры TrainingArguments для обучения. Здесь же добавим параметры от PyTorch 2.0 для быстрого времени обучения. Чтобы использовать последние улучшения PyTorch 2.0 передаем опцию torch_compile в TrainingArguments. Также используем интеграцию Trainer с Hugging Face Hub для загрузки весов модели, логов и метрик в репозиторий во время обучения.

from huggingface_hub import HfFolder
from transformers import Trainer, TrainingArguments

# Id for remote repository
repository_id = "bert-base-banking77-pt2"

# Define training args
training_args = TrainingArguments(
    output_dir=repository_id,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=8,
    learning_rate=5e-5,
 num_train_epochs=3,
 # PyTorch 2.0 specifics
    bf16=True, # bfloat16 training
 torch_compile=True, # optimizations
    optim="adamw_torch_fused", # improved optimizer
    # logging & evaluation strategies
    logging_dir=f"{repository_id}/logs",
    logging_strategy="steps",
    logging_steps=200,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    save_total_limit=2,
    load_best_model_at_end=True,
    metric_for_best_model="f1",
    # push to hub parameters
    report_to="tensorboard",
    push_to_hub=True,
    hub_strategy="every_save",
    hub_model_id=repository_id,
    hub_token=HfFolder.get_token(),

)

# Create a Trainer instance
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset["train"],
    eval_dataset=tokenized_dataset["test"],
    compute_metrics=compute_metrics,
)

Для запуска обучения использем метод train от Trainer.

# Start training
trainer.train()

Теорию по нейронным сетям можно найти тут

Реализация своей нейронной сети с помощью hugging face 🖥 Перед реализацией необходимо сделать следующие шаги: 🔸Настройка окружения и установка PyTorch 2.0. 🔸Загрузка и подготовка датасета. А теперь перейдем к самому главному- Fine-tune и оценка модели BERT с помощью Hugging Face Trainer После подготовки данных можно начинать обучение модели. Мы будем использовать модель bert-base-uncased. Первым шагом будет загрузка модели с помощью класса AutoModelForSequenceClassification из Hugging Face Hub. Так мы создаем модель с весами предобученной модели BERT, но с "головой" сверху специально под нашу задачу классификации. Здесь мы передаем количество классов (77) из нашего набора данных и имена меток, чтобы сделать вывод результатов более читабельным.

from transformers import AutoModelForSequenceClassification

# Model id to load the tokenizer
model_id = "bert-base-uncased"

# Prepare model labels - useful for inference
labels = tokenized_dataset["train"].features["labels"].names
num_labels = len(labels)
label2id, id2label = dict(), dict()
for i, label in enumerate(labels):
    label2id[label] = str(i)
    id2label[str(i)] = label

# Download the model from huggingface.co/models
model = AutoModelForSequenceClassification.from_pretrained(
    model_id, num_labels=num_labels, label2id=label2id, id2label=id2label
)

Будем мониторить качество модели во время обучения. Trainer поддерживает оценку во время обучения, для этого определим compute_metrics. Используем библиотеку evaluate для расчета метрики f1 на тестовом наборе данных.

import evaluate
import numpy as np

# Metric Id
metric = evaluate.load("f1")

# Metric helper method
def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    predictions = np.argmax(predictions, axis=1)
    return metric.compute(predictions=predictions, references=labels, average="weighted")

Разбор алгоритмов #2 Уровень: medium 1. Сортировка слиянием (Merge Sort) Сортировка слиянием — это алгоритм сортировки, который использует принцип "разделяй и властвуй". Он делит массив на две половины, сортирует каждую половину рекурсивно и затем объединяет отсортированные половины.

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]

        merge_sort(left_half)
        merge_sort(right_half)

        i = j = k = 0

        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1

        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

    return arr

# Пример использования
arr = [12, 11, 13, 5, 6, 7]
print("Отсортированный массив:", merge_sort(arr))

Функция merge_sort принимает на вход массив arr. Если длина массива больше 1, продолжаем выполнение. Это условие необходимо для остановки рекурсии. Находим середину массива и делим его на две части: left_half и right_half. Рекурсивно вызываем merge_sort для каждой половины массива. Инициализируем индексы для левой половины (i), правой половины (j) и для объединенного массива (k). Пока не достигнут конец одной из половин, сравниваем элементы из left_half и right_half и добавляем меньший элемент в arr. После завершения основного цикла, добавляем оставшиеся элементы из left_half и right_half в arr и возвращаем отсортированный массив Ссылка на мегаполезные материалы

Разбор алгоритмов 📑 1. Линейный поиск (Linear Search) Линейный поиск проходит по каждому элементу массива, пока не найдет нужный элемент или не дойдет до конца массива.

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

# Пример использования
arr = [2, 4, 6, 8, 10]
target = 6
result = linear_search(arr, target)
print(f"Элемент найден на позиции: {result}")

Функция linear_search проходит по каждому элементу массива arr. Если элемент равен target, возвращается индекс элемента. Если элемент не найден, возвращается -1. 2. Сортировка пузырьком (Bubble Sort) Сортировка пузырьком сравнивает соседние элементы и меняет их местами, если они находятся в неправильном порядке. Этот процесс повторяется до тех пор, пока массив не будет отсортирован.

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# Пример использования
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print(f"Отсортированный массив: {sorted_arr}")

Функция bubble_sort проходит по массиву несколько раз. На каждой итерации она сравнивает соседние элементы и меняет их местами, если они находятся в неправильном порядке. Этот процесс продолжается до тех пор, пока массив не будет отсортирован. 3. Проверка на палиндром (Palindrome Check) Алгоритм проверяет, является ли строка палиндромом (читается одинаково слева направо и справа налево).

def is_palindrome(s):
    return s == s[::-1]

# Пример использования
s = "radar"
print(f"Является ли строка палиндромом? {is_palindrome(s)}")

Функция is_palindrome сравнивает строку с её обратной версией. Если они равны, строка является палиндромом. Ссылка на полезные материалы

WHAT IS AN API? 📌 API (Application Programming Interface) — это механизм для обмена данными между двумя сервисами или приложениями. Пример с рестораном помогает понять этот процесс: 1. "Клиент" (пользователь) делает заказ (запрос) через официанта (API). 2. "Официант" передает заказ на кухню (сервер). 3. "Кухня" готовит еду (ответ) и возвращает её через официанта клиенту. В технических терминах: - Клиентское приложение отправляет HTTP-запрос к серверному приложению через API. - Сервер обрабатывает запрос, иногда извлекает данные из базы данных и отправляет ответ в формате JSON, который нужен клиенту.

Прогнозирование вероятности совершения следующей активности: захода приложение, покупки или любого другого действия с помощью RFM модели. Для определения вероятности используется модель BG/NBD – Beta Geometric / Negative Binomial distribution model. Модель учитывает количество и частоту совершения определенных событий и, на основе этих данных, рассчитывает вероятность того, что пользователь продолжит пользоваться продуктом. Теперь нам надо обучить модель на исторических данных и проверить ее эффективность на части из них. Для этого мы задаем дату, по которой данные обрезаются для обучения, в переменную colibration_period_end, и определяем дату проверочного периода в переменной observation_period_end. Строим прогноз с использованием обученной нами модели для того отрезка данных, который мы оставили для проверки. Фактически в проверяемый период было активно на 22,85% меньше пользователей, чем предсказала наша модель. Для целей быстрой оценки качества трафика эти показатели приемлемы, учитывая скорость оценки активности новых пользователей. Последним шагом необходимо поставить прогнозирование активности на расписание и интегрировать данные с системой закупки трафика, чтобы агрегированные показатели стали доступны маркетологам при принятии решения о перераспределении бюджета между рекламными кампаниями.

Алгоритм бинарного поиска ⚙️ Бинарный поиск — это алгоритм, который используется для нахождения элемента в отсортированном массиве данных. Его основная идея заключается в многократном делении массива пополам, чтобы сузить область поиска. Зачем нужен бинарный поиск? Бинарный поиск значительно ускоряет процесс поиска по сравнению с линейным поиском, особенно в больших массивах. В то время как линейный поиск проверяет каждый элемент последовательно, бинарный поиск сокращает количество проверок, деля массив пополам на каждом шаге. Это делает его очень эффективным, с временной сложностью O(log n), где n — количество элементов в массиве. В книге "Грокаем алгоритмы" Адитьи Бхаргавы алгоритм бинарного поиска объясняется с помощью наглядных иллюстраций и простых примеров. Вот как это выглядит: •Пример с телефонной книгой Представьте, что у вас есть телефонная книга, в которой все имена отсортированы в алфавитном порядке. Вам нужно найти номер телефона человека по имени "Клара". Вместо того чтобы просматривать каждую страницу по порядку, вы можете использовать бинарный поиск: 1. Открываем книгу на середине и смотрим на имя. 2. Сравниваем имя на этой странице с "Клара". - Если имя на странице идет раньше "Клара" в алфавите, значит, "Клара" находится в правой половине книги. - Если имя идет позже, значит, "Клара" в левой половине. - Если имя совпадает, мы нашли нужную страницу. 3. Повторяем процесс для соответствующей половины книги, пока не найдем "Клару". Рассмотрим пример кода, который иллюстрирует этот процесс:

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid  # Элемент найден
        elif arr[mid] < target:
            left = mid + 1  # Ищем в правой половине
        else:
            right = mid - 1  # Ищем в левой половине
    
    return -1  # Элемент не найден

# Пример использования
arr = [1, 3, 5, 7, 9, 11]
target = 7
result = binary_search(arr, target)
print(f"Элемент найден на позиции: {result}")

Этот код выполняет те же шаги, что и в примере с телефонной книгой, но для массива чисел.

Различные типы SQL-соединений 📑 1. INNER JOIN (Внутреннее соединение): 📎Возвращает строки, которые имеют совпадающие значения в обеих таблицах. SQL-запрос:

     SELECT *
     FROM A
     INNER JOIN B ON A.key = B.key
    

2. LEFT JOIN (Левое соединение): - Возвращает все строки из левой таблицы (A) и соответствующие строки из правой таблицы (B). 📎Если в правой таблице нет совпадающих строк, используются NULL-значения. SQL-запрос:

     SELECT *
     FROM A
     LEFT JOIN B ON A.key = B.key
    

3. RIGHT JOIN (Правое соединение): - Аналогично LEFT JOIN, но возвращает все строки из правой таблицы (B). 📎 Если в левой таблице нет совпадающих строк, используются NULL-значения. SQL-запрос:

     SELECT *
     FROM A
     RIGHT JOIN B ON A.key = B.key
    

4. FULL JOIN (Полное соединение): Возвращает все строки из обеих таблиц. 📎Если нет совпадающих строк, используются NULL-значения. SQL-запрос:

     SELECT *
     FROM A
     FULL JOIN B ON A.key = B.key
    WHERE A.key IS NULL OR B.key IS NULL

Базовые типы серверов для веб-сервисов, интернета и т.д. 1. Origin (Исходный сервер) Принимает входящие запросы от внешних клиентов и часто используется для кэширования или других сервисов. 2. Proxy (Прокси-сервер) Действует как посредник для запросов от клиентов, которые ищут ресурсы на других серверах. 3. Mail (Почтовый сервер) Отвечает за отправку и получение электронной почты. 4. Web (Веб-сервер) Предоставляет веб-контент через HTTP-запросы и ответы. 5. DNS (Система доменных имен) Преобразует доменные имена в IP-адреса, действуя как интернет-телефонная книга. 6. API (Интерфейс прикладного программирования) Предоставляет блокоподобный доступ к функциям и данным сервера.

Подборка материалов

Feature engineering 📎 📍практика создания и изменения признаков (столбцов) или переменных в датасете в целях улучшения производительности модели машинного обучения. Рассмотрим базовые методы проектирования объектов   1. Обработка пропущенных значений заполнение пропущенных областей в наборе данных средним значением или медианой столбца.

import pandas as pd
from sklearn.impute import SimpleImputer

# Sample DataFrame
data = {'age': [25, 30, np.nan, 35, 40], 'salary': [50000, 60000, 55000, np.nan, 65000]}
df = pd.DataFrame(data)

# Fill in missing ages using the mean
mean_imputer = SimpleImputer(strategy='mean')
df['age'] = mean_imputer.fit_transform(df[['age']])

# Fill in the missing salaries using the median
median_imputer = SimpleImputer(strategy='median')
df['salary'] = median_imputer.fit_transform(df[['salary']])

print(df)

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

Гонки на python ⚙️

import turtle 
import time 
import random 
 
WIDTH, HEIGHT = 700, 600 
COLORS = ['red', 'green', 'blue', 'orange', 'yellow', 'black', 'purple', 'pink', 'brown', 'cyan'] 
 
def get_number_of_racers(): 
 racers = 0 
 while True: 
  racers = input('Enter the number of racers (2 - 10): ') 
  if racers.isdigit(): 
   racers = int(racers) 
  else: 
   print('Input is not numeric... Try Again!') 
   continue 
 
  if 2 <= racers <= 10: 
   return racers 
  else: 
   print('Number not in range 2-10. Try Again!') 
 
def race(colors): 
 turtles = create_turtles(colors) 
 
 while True: 
  for racer in turtles: 
   distance = random.randrange(1, 20) 
   racer.forward(distance) 
 
   x, y = racer.pos() 
   if y >= HEIGHT // 2 - 10: 
    return colors[turtles.index(racer)] 
 
def create_turtles(colors): 
 turtles = [] 
 spacingx = WIDTH // (len(colors) + 1) 
 for i, color in enumerate(colors): 
  racer = turtle.Turtle() 
  racer.color(color) 
  racer.shape('turtle') 
  racer.left(90) 
  racer.penup() 
  racer.setpos(-WIDTH//2 + (i + 1) * spacingx, -HEIGHT//2 + 20) 
  racer.pendown() 
  turtles.append(racer) 
 
 return turtles 
 
def init_turtle(): 
 screen = turtle.Screen() 
 screen.setup(WIDTH, HEIGHT) 
 screen.title('Turtle Racing!') 
 
racers = get_number_of_racers() 
init_turtle() 
 
random.shuffle(COLORS) 
colors = COLORS[:racers] 
 
winner = race(colors) 
print("The winner is the turtle with color:", winner) 
time.sleep(5)

Подбор гиперпараметров с помощью GridSearchCV Рассмотрим сценарий выбора параметров дерева решений для классификации цветов ириса по набору их признаков. При этом, такие параметры, как •минимальное число членов для разделения (min_samples_split) •максимальная глубина дерева (max_depth) •минимальное число элементов в листе (min_samples_leaf) будут подбираться с использованием класса GridSearchCV. Для этой задачи в библиотеке scikit-learn Python имеется класс GridSearchCV, перебирающий каждое из сочетаний заданных параметров (param_grid), обучающий модель (estimator) и проводящих перекрестную проверку (cv - количество циклов) для выбора лучшей комбинации. После этого в атрибуте .best_estimator_ объекта сохраняется модель с наиболее эффективными настройками. Кроме того, параметр n_jobs GridSearchCV задает количество параллельных процессов, которые могут выполнять поиск, что позволяет оптимизировать распределение процессорных ресурсов.

Deep learning на пальцах- хороший курс для того, чтобы разобраться с современным deep learning с нуля, и не требует знаний ни нейросетей, ни machine learning вообще. 📎 15 лекций с домашними заданиями, обзор задач supervised learning, установка окружения,реализация линейного классификатора,процесс тренировки и overfitting/underfitting на практике, введение в обучение с подкреплением и многое другое

Программа для детекции объектов ( определение местоположения объектов и их классов на изображении)

import cv2
import numpy as np
import os

# Загрузка модели YOLOv8
model = YOLO('yolov8n.pt')

# Список цветов для различных классов
colors = [
    (255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (0, 255, 255),
    (255, 0, 255), (192, 192, 192), (128, 128, 128), (128, 0, 0), (128, 128, 0),
    (0, 128, 0), (128, 0, 128), (0, 128, 128), (0, 0, 128), (72, 61, 139),
    (47, 79, 79), (47, 79, 47), (0, 206, 209), (148, 0, 211), (255, 20, 147)
]

# Функция для обработки изображения
def process_image(image_path):
    # Загрузка изображения
    image = cv2.imread(image_path)
    results = model(image)[0]
    
    # Получение оригинального изображения и результатов
    image = results.orig_img
    classes_names = results.names
    classes = results.boxes.cls.cpu().numpy()
    boxes = results.boxes.xyxy.cpu().numpy().astype(np.int32)

    # Подготовка словаря для группировки результатов по классам
    grouped_objects = {}

    # Рисование рамок и группировка результатов
    for class_id, box in zip(classes, boxes):
        class_name = classes_names[int(class_id)]
        color = colors[int(class_id) % len(colors)]  # Выбор цвета для класса
        if class_name not in grouped_objects:
            grouped_objects[class_name] = []
        grouped_objects[class_name].append(box)

        # Рисование рамок на изображении
        x1, y1, x2, y2 = box
        cv2.rectangle(image, (x1, y1), (x2, y2), color, 2)
        cv2.putText(image, class_name, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

    # Сохранение измененного изображения
    new_image_path = os.path.splitext(image_path)[0] + '_yolo' + os.path.splitext(image_path)[1]
    cv2.imwrite(new_image_path, image)

    # Сохранение данных в текстовый файл
    text_file_path = os.path.splitext(image_path)[0] + '_data.txt'
    with open(text_file_path, 'w') as f:
        for class_name, details in grouped_objects.items():
            f.write(f"{class_name}:\n")
            for detail in details:
                f.write(f"Coordinates: ({detail[0]}, {detail[1]}, {detail[2]}, {detail[3]})\n")

    print(f"Processed {image_path}:")
    print(f"Saved bounding-box image to {new_image_path}")
    print(f"Saved data to {text_file_path}")


process_image('test.png')

В результате работы нейросети получаем объект boxes, который содержит информацию о координатах, найденных на изображении объектов, а также принадлежности их к классу (person, car, bus, traffic light и т.д.) Подробнее о модели YOLOV8

GitHowTo - это интерактивный тур, который познакомит вас с основными командами git

Pro git - полезная документация про ветвление, работу на сервере, инструменты и настройку на git