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

import threading

def task(text):
    print(f"Поток {threading.current_thread().name} обрабатывает: {text}")

# Создаем потоки
threads = []
for i in range(3):
    thread = threading.Thread(target=task, args=(f"текст-{i}",), name=f"Thread-{i}")
    threads.append(thread)
    thread.start()  # Запускаем поток

# Ждем завершения всех потоков
for thread in threads:
    thread.join()

print("Все потоки завершили работу")

from concurrent.futures import ThreadPoolExecutor

def process_text(text):
    return f"Обработано: {text}"

texts = ["отзыв 1", "отзыв 2", "отзыв 3"]

# Создаем пул из 2 потоков
with ThreadPoolExecutor(max_workers=2) as executor:
    # Вариант 1: map (параллельное выполнение)
    results = list(executor.map(process_text, texts))
    
    # Вариант 2: submit (отдельные задачи)
    futures = [executor.submit(process_text, text) for text in texts]
    results = [future.result() for future in futures]

print(results)

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)

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

#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))