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

Что такое паттерны в решении алгоритмических задач Паттерны в решении алгоритмических задач — это типичные подходы или стратегии, которые часто используются для решения определенных классов задач. Каждая задача входит в ряд задач, которые перекрывает определённый паттерн Примеры задач на Окна фикс. длины: ✔️максимальная сумма массива Пересекающиеся окна: ✔️цепочка уникальных генов Не пересекающиеся окна: ✔️Сжатие значений счётчика

Решение алгоритмической задачи с собеседования в Сбер Задача: Объедините два отсортированных связанных списка Описание задачи: Напишите функцию, которая принимает две головы отсортированных односвязных списков и объединяет их в один отсортированный связанный список. Что необходимо знать? Паттерн "dummy node" (или "фиктивный узел") часто используется в задачах, связанных с манипуляцией связанными списками, чтобы упростить обработку крайних случаев, таких как пустой список или изменение головы списка. Суть решения заключается в добавлении "пустой головы" связного списка Пример: Вход: List1: 1 -> 2 -> 4 List2: 1 -> 3 -> 4 Выход: 1 -> 1 -> 2 -> 3 -> 4 -> 4 Решение с использованием паттерна "dummy node" Создайте фиктивный узел, который будет использоваться для упрощения обработки крайних случаев. Используйте два указателя для прохода по each спискам и один указатель для добавления узлов в объединенный список. Переместите указатели по спискам, сравнивая значения узлов и добавляя меньший узел в объединенный список. В конце добавьте оставшиеся узлы из любого списка, если они остались.

class ListNode:
    def __init__(self, value=0, next=None):
        self.value = value
        self.next = next

def mergeTwoLists(list1: ListNode, list2: ListNode) -> ListNode:
    # Создаем фиктивный узел
    dummy = ListNode(0)
    current = dummy

    # Инициализируем указатели для each списка
    p1 = list1
    p2 = list2

    while p1 and p2:
        if p1.value < p2.value:
            current.next = p1
            p1 = p1.next
        else:
            current.next = p2
            p2 = p2.next
        current = current.next

    # Добавляем оставшиеся узлы из любого списка
    if p1:
        current.next = p1
    else:
        current.next = p2

    return dummy.next

# Пример использования
list1 = ListNode(1, ListNode(2, ListNode(4)))
list2 = ListNode(1, ListNode(3, ListNode(4)))
merged_head = mergeTwoLists(list1, list2)

# Функция для печати списка
def printList(head: ListNode):
    current = head
    while current:
        print(current.value, end=" -> ")
        current = current.next
    print("None")

printList(merged_head)

В этой задаче паттерн "dummy node" упрощает обработку крайних случаев, таких как пустые списки или списки с одним элементом

Основные понятия или как запускать коды из канала, чтобы они работали 🔋 1 Что такое модель? Модель- алгоритм, позволяющий обрабатывать наши данные так, чтобы получился желаемый результат (прогнозирование, классификация и т. д.) 2 Что такое метрика? Метрика- математическая оценка того, насколько хорошо или плохо работает модель 3. Как загрузить модель? Загрузка происходит путём импортирования из библиотек: import *название библиотеки* 4. Что делать если модель не импортируется? Значит нужно установить эту библиотеку: Pip install *название библиотеки* 5. Как скормить модели свои данные или загрузить существующие? df = pd.read_csv("название файла") Файл с данными должен храниться в той же папке, что и код 6.Как посмотреть на данные? df.head() df- переменная, в которой хранятся данные 7.Где запускать код? • Visual Studio Code • Google Colab

Статьи и публикации Стэнфордского университета про LLM *LLM-модели, способные распознавать, переводить, прогнозировать или генерировать текст или другой контент

Перевод аудио в текст с помощью нейронной сети📌 Часть 2

audio = whisper.pad_or_trim(audio_13)

#Number of samples in our trimmed/padded audio
n_samples =  audio.shape[-1]
#Time of each sample
time = np.linspace(0,(n_samples-1)*delta,n_samples)

plt.figure(figsize=(20,10))
plt.title('Signal')
plt.plot(time,audio)
plt.ylabel('amplitude')
plt.xlabel('seconds')
plt.show()

"""Next, we can start plotting a mel spectogram by applying a log_mel_spectogram() funtion to our audio file. It converts the y-axis (frequency) into the mel scale:"""

mel = whisper.log_mel_spectrogram(audio).to(model_m.device)

fig, (ax1, ax2) = plt.subplots(2)
fig.tight_layout(pad=5.0)
ax1.plot(time,audio)
ax1.set_title('Signal')
ax1.set_xlabel('Time, seconds')
ax1.set_ylabel('Amplitude')
ax2.imshow((mel.numpy()*mel.numpy())**(1/2),interpolation='nearest', aspect='auto')
ax2.set_title('Mel Spectrogram of a Signal')
ax2.set_xlabel('Time, seconds')
ax2.set_ylabel('Mel Scale')

#Next, we can move on to language detection.

#Language detection

sr=22050
ipd.Audio(audio, rate=sr)

probs = model_m.detect_language(mel)

probs

#Transcription

file_path2= 'Rec.mp3'

transcription = model_m.transcribe(file_path2, fp16 = False)['text']

transcription

Перевод аудио в текст с помощью нейронной сети📌 Часть 1. Загрузка модели и аудио файла

#Importing the necessary libraries
import torch
import whisper
import pytube
import librosa
import matplotlib.pyplot as plt
import numpy as np
import IPython.display as ipd

#Loading the Model

model_m = whisper.load_model('medium')

#Loading the file 
# вставьте сюда ваш файл

file_path = '/content/Rec.mp3'

#Loading
audio_13 = whisper.load_audio(file_path)
audio_13

#Задаем время голосовго файла - 12 секунд
T = 12
#Checking the number of samples in our audio file
n_samples =  audio_13.shape[0]
#Time between samples
delta = T/n_samples
#Sampling frequency
Fs = 1/delta
#Time of each sample
time = np.linspace(0,(n_samples-1) * delta,n_samples)
time

#Now we plot the amplitude with respect to time:

plt.figure(figsize=(20,10))
plt.title('Signal')
plt.plot(time,audio_13)
plt.ylabel('amplitude')
plt.xlabel('seconds')
plt.show()

Тема, которую необходимо освоить перед тем, как вникать в рекомендательные системы -ранжирование Ранжирование от ВШЭ Ранжирование от Яндекса Основные подходы ранжирования Ранжирование с нуля

Тема, которую необходимо освоить перед тем, как вникать в рекомендательные системы -ранжирование Ранжирование от ВШЭ Ранжирование от Яндекса Основные подходы ранжирования Ранжирование с нуля

Создание системы рекомендаций

from collections import Counter
import datetime

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.utils import shuffle

from models.features.topics import topics_similarity
from models.features.cosine import cosine_similarity_features

clf = RandomForestClassifier()
clf_one = RandomForestClassifier()
clf_two = RandomForestClassifier()

def generate_features(data, val=None):
    features = []
    for raw in data:
        features.extend(topics_similarity(raw))
    features.extend(cosine_similarity_features(data[:-1], data[-1]))

    if val is None:
        return features
    else:
        return features, val


def generate_data(data):
    x_true = []
    y_true = []
    x_false = []
    y_false = []
    print('Start generate features.')
    for urls in data.sequences.find():
        features = generate_features(data.get_articles_data(urls['urls']), 1)
        x_true.append(features[0])
        y_true.append(features[1])

    print('Start generate random data.')
    while len(x_true) != len(x_false):
        features = generate_features(data.get_random_articles(4), 0)
        x_false.append(features[0])
        y_false.append(features[1])

    return x_true + x_false, y_true + y_false


def init(data):
    try:
        x = np.load(open('train_x.np', 'rb'))
        y = np.load(open('train_y.np', 'rb'))
    except FileNotFoundError:
        x, y = generate_data(data)
        np.save(open('train_x.np', 'wb'), x)
        np.save(open('train_y.np', 'wb'), y)
    x, y = shuffle(x, y)
    x_one = list(map(lambda a: a[:81], x))
    x_two = list(map(lambda a: a[:122], x))

    print('Train model for 3 articles.')
    clf.fit(x, y)

    print('Train model for 1 article.')
    clf_one.fit(x_one, y)

    print('Train model for 2 articles.')
    clf_two.fit(x_two, y)


def predict(input_articles, input_ids,tvrain_data, recommends_num):
    result_counter = Counter()
    min_time = input_articles[0]['time'] - datetime.timedelta(hours=5)
    max_time = input_articles[-1]['time'] + datetime.timedelta(hours=5)
    mongo_query = {'time': {'$gt': min_time, '$lt': max_time}}
    len_articles = len(input_articles)
    # Gen for articles in Mongo
    for article in tvrain_data.iterate_articles(except_articles=input_ids, query=mongo_query):
        new_features = generate_features(input_articles + [article])
        if len_articles == 3:
            result = clf.predict_proba([new_features])
        elif len_articles == 2:
            result = clf_two.predict_proba([new_features])
        elif len_articles == 1:
            result = clf_one.predict_proba([new_features])
        result_counter[article['_id']] = result[0][1]
    return list(result_counter.most_common(recommends_num))

Материалы по данной теме

Создание системы рекомендаций ☸️ 🔸Среди рекомендательных систем выделяются три основных типа: коллаборативная фильтрация, контетная и гибридная. 🔸Коллаборативная фильтрация - наверное, наиболее популярная модель для рекомендации объектов. Её основная идея заключается в том, что если объекты смотрят почти одинаковые пользователи, то эти объекты стоит рекомендовать этим пользователям. В коллаборативной фильтрации выделяется два основных подхода: 🔶Корреляционные модели - основная идея таких моделий основана на хранении матрицы пользователей/объектов. 🔶Латентные модели - модели, которые позволяют не держать матрицу пользователей/объектов, а строятся на основе 'профилей' пользователей и объектов. Профиль - это вектор скрытых характеристик. 🔸Следующий способ построения рекомендательной модели - контетные рекомендации. Это значит, что наша модель будет зависеть от содержимого объектов. Например, можно оценивать похожесть текстов новостей (о том, как именно этот делать - чуть позже) или к фильму "Титаник" рекомендовать другие фильмы Кэмерона. Главная идея этого метода заключается в том, что мы пытаемся достать как можно большую информацию об объекте, который мы хотим порекомендовать, и используем эту информацию для поиска таких же объектов, после чего мы просто рекомендуем похожие объекты. 🔸Наша гибридная модель на основе признаков, которые мы вытащили для объекта и для пользователя возвращает вероятность того, что пользователь прочитает эту статью (кликнет на неё).

if len_articles == 3: result = clf.predict_proba([new_features]) elif len_articles == 2: result = clf_two.predict_proba([new_features]) elif len_articles == 1: result = clf_one.predict_proba([new_features]) result_counter[article['_id']] = result[0][1] return list(result_counter.most_common(recommends_num)) `

Создание системы рекомендаций ☸️ 🔸Среди рекомендательных систем выделяются три основных типа: коллаборативная фильтрация, контетная и гибридная. 🔸Коллаборативная фильтрация - наверное, наиболее популярная модель для рекомендации объектов. Её основная идея заключается в том, что если объекты смотрят почти одинаковые пользователи, то эти объекты стоит рекомендовать этим пользователям. В коллаборативной фильтрации выделяется два основных подхода: 🔶Корреляционные модели - основная идея таких моделий основана на хранении матрицы пользователей/объектов. 🔶Латентные модели - модели, которые позволяют не держать матрицу пользователей/объектов, а строятся на основе 'профилей' пользователей и объектов. Профиль - это вектор скрытых характеристик. 🔸Следующий способ построения рекомендательной модели - контетные рекомендации. Это значит, что наша модель будет зависеть от содержимого объектов. Например, можно оценивать похожесть текстов новостей (о том, как именно этот делать - чуть позже) или к фильму "Титаник" рекомендовать другие фильмы Кэмерона. Главная идея этого метода заключается в том, что мы пытаемся достать как можно большую информацию об объекте, который мы хотим порекомендовать, и используем эту информацию для поиска таких же объектов, после чего мы просто рекомендуем похожие объекты. 🔸Наша гибридная модель на основе признаков, которые мы вытащили для объекта и для пользователя возвращает вероятность того, что пользователь прочитает эту статью (кликнет на неё). ` from collections import Counter import datetime import numpy as np from sklearn.ensemble import RandomForestClassifier from sklearn.utils import shuffle from models.features.topics import topics_similarity from models.features.cosine import cosine_similarity_features clf = RandomForestClassifier() clf_one = RandomForestClassifier() clf_two = RandomForestClassifier() def generate_features(data, val=None): features = [] for raw in data: features.extend(topics_similarity(raw)) features.extend(cosine_similarity_features(data[:-1], data[-1])) if val is None: return features else: return features, val def generate_data(data): x_true = [] y_true = [] x_false = [] y_false = [] print('Start generate features.') for urls in data.sequences.find(): features = generate_features(data.get_articles_data(urls['urls']), 1) x_true.append(features[0]) y_true.append(features[1]) print('Start generate random data.') while len(x_true) != len(x_false): features = generate_features(data.get_random_articles(4), 0) x_false.append(features[0]) y_false.append(features[1]) return x_true + x_false, y_true + y_false def init(data): try: x = np.load(open('train_x.np', 'rb')) y = np.load(open('train_y.np', 'rb')) except FileNotFoundError: x, y = generate_data(data) np.save(open('train_x.np', 'wb'), x) np.save(open('train_y.np', 'wb'), y) x, y = shuffle(x, y) x_one = list(map(lambda a: a[:81], x)) x_two = list(map(lambda a: a[:122], x)) print('Train model for 3 articles.') clf.fit(x, y) print('Train model for 1 article.') clf_one.fit(x_one, y) print('Train model for 2 articles.') clf_two.fit(x_two, y) def predict(input_articles, input_ids,tvrain_data, recommends_num): result_counter = Counter() min_time = input_articles[0]['time'] - datetime.timedelta(hours=5) max_time = input_articles[-1]['time'] + datetime.timedelta(hours=5) mongo_query = {'time': {'$gt': min_time, '$lt': max_time}} len_articles = len(input_articles) # Gen for articles in Mongo for article in tvrain_data.iterate_articles(except_articles=input_ids, query=mongo_query): new_features = generate_features(input_articles + [article])

Для тех, кто только хочет окунуться в DL с уклоном на CV, Мюнхенский университет выпустил открытый курс с лекциями и задачами

Неделю назад участвовали в хакатоне, хочу поделиться некоторыми инсайтами от задачи. Задача заключалась в создании сервиса, который получает статью, преобразует ее в диалог между отцом и дочерью, где отец объясняет какую-то тему, а затем этот диалог озвучивается. Разработали следующую архитектуру: парсер для ссылок отправлял текст в настроенную модель GPT, которая создавала диалог из статьи, после чего модель синтеза речи озвучивала его. Все это было завернуто в Docker-контейнер и запущено на виртуальной машине. Однако столкнулись с проблемой: SSML-разметка не работала, озвучка была монотонной, без правильных ударений, а также размер токенов часто превышал допустимое значение. Для решения проблем решили попробовать подход prompt engineering. Мы создали километровый промпт, в котором подробно прописывали интонации, возможные ошибки и способы их устранения.По сути, все наши проблемы модель GPT сама устраняла, что было достаточно удобно. В итоге заняли шестое место. В условиях бекендерской задачи для ML-инженеров использование prompt engineering оказалось наилучшим решением. А тот факт, что весь код держался на одном длинном промпте, уже не баг,а фича, как говорится 🤔 Так вот, теперь инсайт: Не стоит недооценивать promt engineering, но и про промт инъекции забывать нельзя

Неделю назад участвовали в хакатоне, хочу поделиться некоторыми инсайтами от задачи. Задача заключалась в создании сервиса, который получает статью, преобразует ее в диалог между отцом и дочерью, где отец объясняет какую-то тему, а затем этот диалог озвучивается. Разработали следующую архитектуру: парсер для ссылок отправлял текст в настроенную модель GPT, которая создавала диалог из статьи, после чего модель синтеза речи озвучивала его. Все это было завернуто в Docker-контейнер и запущено на виртуальной машине. Однако столкнулись с проблемой: SSML-разметка не работала, озвучка была монотонной, без правильных ударений, а также размер токенов часто превышал допустимое значение. Для решения проблем решили попробовать подход prompt engineering. Мы создали километровый промпт, в котором подробно прописывали интонации, возможные ошибки и способы их устранения.По сути, все наши проблемы модель GPT сама устраняла, что было достаточно удобно. В итоге заняли шестое место. В условиях бекендерской задачи для ML-инженеров использование prompt engineering оказалось наилучшим решением. А тот факт, что весь код держался на одном длинном промпте, уже не баг,а фича, как говорится. Только вот учесть промт инъекции уже не оставалось времени 🤔 Так вот, теперь инсайт: Не стоит недооценивать promt engineering, но и переоценивать тоже такое себе

Часть 3: обучение нейронной сети. 📎 Теперь мы приступаем к обучению модели. Для этого нам нужно вызвать функцию fit () для модели и передать выбранные параметры. Вот где используется SEED, выбранный в целях воспроизводимости.

numpy.random.seed(seed)
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=epochs, batch_size=64)

Теперь мы можем оценить модель и посмотреть, как она работает. Просто вызовите model.evaluate():

# Model evaluation
scores = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

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

Часть 2. Следующий этап: проектирование модели.

model = Sequential()

Первый слой нашей модели - это сверточный слой. Он будет принимать входные данные и пропускать их через сверточные фильтры.

model.add(Conv2D(32, (3, 3), input_shape=X_train.shape[1:], padding='same'))
model.add(Activation('relu'))

Теперь мы создадим исключающий слой для предотвращения переобучения, который случайным образом устраняет соединения между слоями (0,2 означает, что он отбрасывает 20% существующих соединений):

model.add(Dropout(0.2))

model.add(BatchNormalization())

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

model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))

А вот и объединяющий слой, который помогает сделать классификатор изображений более корректным

model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(BatchNormalization())

Это основа рабочего процесса в первой части реализации CNN: свертка, активация, исключение, объединение. Теперь вы можете повторить эти слои, чтобы дать вашей сети больше представлений для работы:

model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Conv2D(128, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(BatchNormalization())

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

model.add(Flatten())
model.add(Dropout(0.2))

Теперь мы используем импортированную функцию Dense и создаем первый плотно связанный слой. Нам нужно указать количество нейронов в плотном слое. Обратите внимание, что число нейронов в последующих слоях уменьшается, в конечном итоге приближаясь к тому же числу нейронов, что и классы в наборе данных (в данном случае 10). Ограничение ядра может упорядочить данные в процессе обучения, что также помогает предотвратить переобучение. Вот почему мы импортировали maxnorm ранее.

model.add(Dense(256, kernel_constraint=maxnorm(3)))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(128, kernel_constraint=maxnorm(3)))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(BatchNormalization())

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

model.add(Dense(class_num))
model.add(Activation('softmax'))

Теперь, когда мы разработали модель, которую хотим использовать, остаётся лишь скомпилировать ее. Давайте укажем количество эпох для обучения, а также оптимизатор, который мы хотим использовать. Оптимизатор - это то, что настроит веса в вашей сети так, чтобы приблизиться к точке с наименьшими потерями. Алгоритм Адама является одним из наиболее часто используемых оптимизаторов

epochs = 25
optimizer = 'adam'

model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])