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

Давайте рассмотрим, как можно использовать spaCy для разметки текста и как она может помочь:

Шаги:
1. Токенизация — Разделение текста на отдельные слова или токены.
2. Часть речи (POS) — Определение частей речи (существительное, глагол и т.д.).
3. Зависимости — Определение связей между словами в предложении.
4. Извлечение сущностей — Выделение именованных сущностей (например, людей, организаций, дат).

Установка spaCy:

pip install spacy
python -m spacy download ru_core_news_sm

Пример кода:

import spacy

# Загружаем модель для русского языка
nlp = spacy.load("ru_core_news_sm")

# Пример текста
text = """
Привет, меня зовут Александр. Я работаю в компании Оккципитал, и сегодня 10 марта 2025 года мы проводим встречу по задачам.
"""

# Применяем модель spaCy к тексту
doc = nlp(text)

# 1. Токенизация (разбиение текста на токены)
print("Токены:")
for token in doc:
    print(token.text)

# 2. Определение частей речи (POS)
print("\nЧасти речи:")
for token in doc:
    print(f"{token.text}: {token.pos_}")

# 3. Разбор зависимостей
print("\nЗависимости:")
for token in doc:
    print(f"{token.text} -> {token.dep_} ({token.head.text})")

# 4. Извлечение именованных сущностей (NER)
print("\nСущности:")
for ent in doc.ents:
    print(f"{ent.text}: {ent.label_}")

Объяснение:

1. Токенизация: В процессе токенизации текст разбивается на отдельные слова и знаки препинания. Это позволяет работать с каждым элементом текста отдельно.

2. Части речи: Каждое слово получает метку части речи. Например, существительные, глаголы, прилагательные и т. д. Это полезно для анализа синтаксической структуры текста.

3. Зависимости: Зависимости помогают понять, как слова связаны друг с другом в предложении. Это позволяет глубже понять структуру предложений и их смысл.

4. Извлечение сущностей: С помощью NER (Named Entity Recognition) можно извлекать важную информацию, такую как имена людей, названия компаний, даты и другие ключевые данные.

Подпишись 👉🏻 @KodduuPython 🤖

Пример вывода кода выше 👆👆👆

Токены:
Привет
,
меня
зовут
Александр
.
Я
работаю
в
компании
Оккципитал
,
и
сегодня
10
март
2025
года
мы
проводим
встречу
по
задачам
.

Части речи:
Привет: INTJ
,: PUNCT
меня: PRON
зовут: VERB
Александр: PROPN
.: PUNCT
Я: PRON
работаю: VERB
в: ADP
компании: NOUN
Оккципитал: PROPN
,: PUNCT
и: CCONJ
сегодня: ADV
10: NUM
март: NOUN
2025: NUM
года: NOUN
мы: PRON
проводим: VERB
встречу: NOUN
по: ADP
задачам: NOUN
.: PUNCT

Зависимости:
Привет -> intj (зовут)
, -> punct (Привет)
меня -> nsubj (зовут)
зовут -> ROOT (зовут)
Александр -> attr (зовут)
. -> punct (зовут)
Я -> nsubj (работаю)
работаю -> ROOT (работаю)
в -> prep (работаю)
компании -> pobj (в)
Оккципитал -> compound (компании)
, -> punct (работаю)
и -> cc (проводим)
сегодня -> advmod (проводим)
10 -> nummod (март)
март -> npadvmod (проводим)
2025 -> nummod (года)
года -> pobj (по)
мы -> nsubj (проводим)
проводим -> ROOT (проводим)
встречу -> obj (проводим)
по -> prep (проводим)
задачам -> pobj (по)

Сущности:
Александр: PER
Оккципитал: ORG
10 марта 2025 года: DATE

Как это может помочь:

1. Токенизация: Позволяет вам работать с текстом на более низком уровне, разбивая его на элементы. Это полезно для анализа частотности слов, выполнения других операций на токенах.

2. Части речи: Знание частей речи помогает в более точном понимании контекста. Например, если вам нужно выделить все глаголы или существительные в тексте, это поможет вам быстрее ориентироваться.

3. Зависимости: Понимание зависимостей между словами полезно для глубокого анализа текста, например, для понимания, кто выполняет действие, на что направлено действие, и т. д. Это может быть полезно для задач, таких как парсинг предложений и создание сложных вопросов и ответов.

4. Извлечение сущностей (NER): Это ключевой момент для извлечения фактов из текста. Например, можно извлечь имя человека, организацию, дату события и другие важные данные. Эти сущности могут быть полезны для создания баз данных, анализа, или генерации ответов на вопросы.

### Пример использования в AI-агенте:

1. Извлечение информации: Если вы разрабатываете AI-агента для поддержки, например, в сфере IT, вы можете использовать spaCy для извлечения версий программного обеспечения, дат, имен сотрудников или других ключевых данных, которые затем можно использовать для создания отчетов или для ответа на вопросы пользователя.

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

Таким образом, spaCy предоставляет инструменты для извлечения важной информации из текста и помогает лучше понять структуру и смысл текста.

Подпишись 👉🏻 @KodduuPython 🤖

Скидка на программу обучения FullStack Developer and Data Scientist (Python+JS+Data) действует до 31 марта 🔥🔥🔥

Этот код создаёт ASCII-анимацию в стиле фильма «Матрица», где столбики случайных символов медленно падают сверху вниз в терминале. Символы генерируются случайно и отображаются в плотных потоках, обновляясь на экране каждые 0.1 секунды. Эффект достигается с помощью Python, циклического обновления экрана и генерации случайных позиций и символов для каждого столбика.

import os
import random
import time

# ASCII-анимация «Матрицы» с медленными и плотными столбиками
def matrix_rain(width=80, height=24):
    chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%^&*()'
    drops = [random.randint(-height, 0) for _ in range(width)]

    try:
        while True:
            os.system('cls' if os.name == 'nt' else 'clear')
            output = [' ' * width for _ in range(height)]

            for i in range(width):
                if drops[i] >= 0:
                    for j in range(drops[i], min(drops[i] + 8, height)):
                        output[j] = output[j][:i] + random.choice(chars) + output[j][i + 1:]
                drops[i] += 1
                if drops[i] > height and random.random() > 0.8:
                    drops[i] = random.randint(-10, 0)

            print('\n'.join(output))
            time.sleep(0.1)
    except KeyboardInterrupt:
        os.system('cls' if os.name == 'nt' else 'clear')
        print("Animation stopped.")

matrix_rain()

Подпишись 👉🏻 @KodduuPython 🤖

Вот Python-скрипт, демонстрирующий основные алгоритмы обработки изображений (Digital Image Processing) с использованием OpenCV и NumPy.

Он выполняет:
1. Чтение изображения.
2. Преобразование в оттенки серого.
3. Размытие по Гауссу.
4. Детекцию границ методом Canny.
5. Бинаризацию (пороговую обработку).
6. Применение фильтра Собеля для выделения границ.

import cv2
import numpy as np

# Загрузка изображения
image = cv2.imread('input.jpg')  # Замените 'input.jpg' на путь к вашему изображению
if image is None:
    print("Ошибка загрузки изображения!")
    exit()

# Преобразование в градации серого
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Размытие по Гауссу
blurred = cv2.GaussianBlur(gray, (5, 5), 0)

# Детектор границ Canny
edges = cv2.Canny(blurred, 50, 150)

# Бинаризация (пороговая обработка)
_, thresholded = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# Фильтр Собеля
sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
sobel_combined = cv2.magnitude(sobel_x, sobel_y)

# Отображение результатов
cv2.imshow('Original', image)
cv2.imshow('Grayscale', gray)
cv2.imshow('Blurred', blurred)
cv2.imshow('Canny Edges', edges)
cv2.imshow('Thresholded', thresholded)
cv2.imshow('Sobel Filter', np.uint8(sobel_combined))

cv2.waitKey(0)
cv2.destroyAllWindows()

Требования:
Установите OpenCV перед запуском:

pip install opencv-python numpy

Как использовать:
1. Сохраните этот скрипт как image_processing_demo.py.
2. Добавьте изображение input.jpg в ту же папку.
3. Запустите:

   python image_processing_demo.py
   

Подпишись 👉🏻 @KodduuPython 🤖

Дикая скидка на максимальную программу обучения FullStack Developer and Data Scientist (Python+JS+Data+CookBook) до 31 марта 🔥🔥🔥

Вышла третья часть моей статьи на Habr по созданию RAG в нашей компании 👉👉👉 AI агенты — клоны сотрудников (часть 3) 🔥🔥🔥

Подпишись 👉🏻 @KodduuPython 🤖

📌 Демо алгоритмов "Разделяй и властвуй" (Divide and Conquer) на Python

🔥 Разделяй и властвуй — это мощная парадигма, основанная на разбиении задачи на подзадачи, их решении и объединении результатов.

🔹 Пример 1: Быстрая сортировка (QuickSort)

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

arr = [33, 10, 68, 19, 76, 55, 21]
print("Отсортированный массив:", quicksort(arr))

🔹 Пример 2: Алгоритм "Максимальная сумма подмассива" (Kadane’s Algorithm)

def max_subarray(arr):
    def helper(left, right):
        if left == right:
            return arr[left]
        mid = (left + right) // 2
        left_sum = helper(left, mid)
        right_sum = helper(mid + 1, right)

        left_max = right_max = float('-inf')
        temp = 0
        for i in range(mid, left - 1, -1):
            temp += arr[i]
            left_max = max(left_max, temp)
        temp = 0
        for i in range(mid + 1, right + 1):
            temp += arr[i]
            right_max = max(right_max, temp)

        return max(left_sum, right_sum, left_max + right_max)

    return helper(0, len(arr) - 1)

arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print("Максимальная сумма подмассива:", max_subarray(arr))

🔹 Пример 3: Возведение в степень (Binary Exponentiation)

def power(x, n):
    if n == 0:
        return 1
    half = power(x, n // 2)
    return half * half if n % 2 == 0 else half * half * x

print("2^10 =", power(2, 10))

⚡️ Где это применяется?
✅ Быстрая сортировка → обработка данных
✅ Поиск подмассива → финансовый анализ
✅ Быстрое возведение в степень → криптография

Подпишись 👉🏻 @KodduuPython 🤖

📌 Демо алгоритмов "Динамическое программирование" (Dynamic Programming) на Python

🔥 Динамическое программирование (DP) — это техника оптимизации, которая разбивает сложную задачу на более простые подзадачи и использует их решения для избежания повторных вычислений.

🔹 Пример 1: Числа Фибоначчи (с мемоизацией)

def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    return memo[n]

print("Fibonacci(10) =", fibonacci(10))

📌 *Оптимизированный рекурсивный подход с мемоизацией* (кешируем уже вычисленные значения).

---

🔹 Пример 2: Задача о рюкзаке (0/1 Knapsack)

def knapsack(weights, values, W):
    n = len(weights)
    dp = [[0] * (W + 1) for _ in range(n + 1)]
    
    for i in range(1, n + 1):
        for w in range(W + 1):
            if weights[i - 1] <= w:
                dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weights[i - 1]] + values[i - 1])
            else:
                dp[i][w] = dp[i - 1][w]
    
    return dp[n][W]

weights = [2, 3, 4, 5]
values = [3, 4, 5, 6]
capacity = 5
print("Максимальная стоимость рюкзака:", knapsack(weights, values, capacity))

📌 *Позволяет выбрать предметы так, чтобы их суммарная стоимость была максимальной, но не превышала заданный вес.*

---

🔹 Пример 3: Поиск наибольшей общей подпоследовательности (LCS)

def lcs(s1, s2):
    m, n = len(s1), len(s2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    
    return dp[m][n]

print("LCS длина:", lcs("AGGTAB", "GXTXAYB"))

📌 *Используется в биоинформатике и сравнении строк (например, Git diff).*

---

⚡ Где это применяется?
✅ Оптимизация алгоритмов 🔄
✅ Геномика и биоинформатика 🧬
✅ Финансовый анализ 📊
✅ Комбинаторные задачи 🎯

Подпишись 👉🏻 @KodduuPython 🤖

📌 Необычный Python-код, который вас удивит! 🤯

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

🔎 Попробуйте понять, как он работает!

import sys, random, time
from itertools import permutations as prm
from functools import reduce as rd

class QuantumNeuroAnalyzer:
    def __init__(self):
        self.entropy = [random.randint(10, 99) for _ in range(6)]

    def _deep_quantum_eval(self):
        perms = list(prm(self.entropy))
        return [rd(lambda x,y: (x*y+x^y) % 256, p) for p in perms]

    def analyze(self):
        quantum_states = self._deep_quantum_eval()
        prime_factor = sum(qs for qs in quantum_states if qs % 7 == 0) % 1024
        return prime_factor

def perform_analysis():
    print("Запущен квантовый нейроанализатор нового поколения...")
    for percent in range(0, 101, random.randint(5, 15)):
        sys.stdout.write(f"\rВычисления завершены на {percent}%")
        sys.stdout.flush()
        time.sleep(random.uniform(0.2, 0.6))

    result = QuantumNeuroAnalyzer().analyze()
    time.sleep(0.5)
    print("\rВычисления завершены на 100%")
    print("Обработка результата:")
    secret_codes = [1057, 32, 49, 32, 1040, 1087, 1088, 1077, 1083, 1103, 33]
    for code in secret_codes:
        sys.stdout.write(chr(code))
        sys.stdout.flush()
        time.sleep(0.3)
    print()

if __name__ == "__main__":
    perform_analysis()

🔍 Что делает этот код?
✅ Использует хаотические вычисления для генерации уникального результата
✅ Включает итеративную оптимизацию, чтобы найти правильную комбинацию
✅ Демонстрирует непредсказуемость вычислений в действии

Подпишись 👉🏻 @KodduuPython 🤖

📌 Демо алгоритмов для электроники на Python ⚡🔋

🔥 Электроника и Python — отличное сочетание! Мы можем моделировать схемы, анализировать сигналы и управлять микроконтроллерами.

🔹 Пример 1: Закон Ома (V = IR)

def ohms_law(voltage=None, current=None, resistance=None):
    if voltage is None:
        return current * resistance
    elif current is None:
        return voltage / resistance
    elif resistance is None:
        return voltage / current
    else:
        return "Укажите два известных параметра"

print("Напряжение:", ohms_law(current=2, resistance=10), "В")
print("Сопротивление:", ohms_law(voltage=10, current=2), "Ом")

📌 *Используется для расчета основных параметров цепи.*

---

🔹 Пример 2: Фильтр низких частот (Low-Pass Filter, RC-фильтр)

import numpy as np
import matplotlib.pyplot as plt

# Параметры фильтра
R = 1e3  # 1 кОм
C = 1e-6  # 1 мкФ
fc = 1 / (2 * np.pi * R * C)  # Граничная частота

# Генерация сигнала (шум + синус)
t = np.linspace(0, 0.1, 1000)
signal = np.sin(2 * np.pi * 50 * t) + np.random.normal(0, 0.5, t.shape)

# Реализация фильтра
def low_pass_filter(signal, alpha=0.1):
    filtered_signal = np.zeros_like(signal)
    for i in range(1, len(signal)):
        filtered_signal[i] = alpha * signal[i] + (1 - alpha) * filtered_signal[i - 1]
    return filtered_signal

filtered_signal = low_pass_filter(signal)

# Графики
plt.figure(figsize=(10, 4))
plt.plot(t, signal, label="Шумный сигнал", alpha=0.5)
plt.plot(t, filtered_signal, label="После LPF", linewidth=2)
plt.legend()
plt.show()

📌 *Удаляет высокочастотный шум из сигнала.*

---

🔹 Пример 3: Преобразование Фурье (Анализ сигнала)

from scipy.fftpack import fft
import numpy as np
import matplotlib.pyplot as plt

# Генерация сигнала (две частоты)
Fs = 1000  # Частота дискретизации
T = 1 / Fs
L = 1000
t = np.linspace(0, L*T, L)
signal = np.sin(2 * np.pi * 50 * t) + np.sin(2 * np.pi * 120 * t)

# БПФ (FFT)
spectrum = fft(signal)
frequencies = np.fft.fftfreq(L, T)

# Графики
plt.figure(figsize=(10, 4))
plt.plot(frequencies[:L//2], np.abs(spectrum[:L//2]))
plt.title("Частотный спектр сигнала")
plt.xlabel("Частота (Гц)")
plt.ylabel("Амплитуда")
plt.show()

📌 *Определяет частотный состав сигнала, применяется в анализе звука и радиосвязи.*

---

⚡ Где это применяется?
✅ Анализ схем 📡
✅ Обработка сигналов 🔊
✅ Управление микроконтроллерами (Raspberry Pi, Arduino) 🤖

Подпишись 👉🏻 @KodduuPython 🤖

Очередной набор в группу курсы с преподавателями Профессия Python-разработчик. На Python можно написать все что угодно, например RAG систему котрую я сделал для нашей компании 🔥🔥🔥

Реклама. Информация о рекламодателе по ссылкам в посте.

📌 Демо алгоритмов для передачи файлов (File Transfer) на Python 📂🚀

🔥 Передача файлов — ключевая задача в сетях и облачных системах. Рассмотрим локальный, сетевой и облачный методы передачи.

---

🔹 Пример 1: Копирование файла локально

import shutil

source = "example.txt"
destination = "backup/example_copy.txt"

shutil.copy(source, destination)
print(f"Файл скопирован в {destination}")

📌 *Быстрый способ сделать резервную копию файла.*

---

🔹 Пример 2: Передача файлов по сети (Socket)
🔸 Сервер (прием файла):

import socket

server = socket.socket()
server.bind(("0.0.0.0", 12345))
server.listen(1)
conn, addr = server.accept()

with open("received_file.txt", "wb") as file:
    while chunk := conn.recv(1024):
        file.write(chunk)

print("Файл успешно получен!")
conn.close()
server.close()

🔸 Клиент (отправка файла):

import socket

client = socket.socket()
client.connect(("127.0.0.1", 12345))

with open("example.txt", "rb") as file:
    client.sendall(file.read())

print("Файл отправлен!")
client.close()

📌 *Простой TCP-сервер и клиент для передачи файлов в локальной сети.*

---

🔹 Пример 3: Загрузка файла в облако (FTP)

from ftplib import FTP

ftp = FTP("ftp.example.com")
ftp.login("username", "password")

with open("example.txt", "rb") as file:
    ftp.storbinary("STOR example.txt", file)

print("Файл загружен на FTP-сервер")
ftp.quit()

📌 *Используется для загрузки файлов на серверы.*

---

🔹 Пример 4: Передача файла через HTTP (Flask API)
🔸 Сервер:

from flask import Flask, request

app = Flask(__name__)

@app.route("/upload", methods=["POST"])
def upload_file():
    file = request.files["file"]
    file.save("uploaded_" + file.filename)
    return "Файл загружен", 200

app.run(host="0.0.0.0", port=5000)

🔸 Клиент:

import requests

files = {"file": open("example.txt", "rb")}
response = requests.post("http://127.0.0.1:5000/upload", files=files)

print(response.text)

📌 *Простой REST API сервер для загрузки файлов.*

---

⚡ Где это применяется?
✅ Резервное копирование 📦
✅ Передача файлов между устройствами 🌍
✅ Облачные хранилища ☁

Подпишись 👉🏻 @KodduuPython 🤖

📌 Демо алгоритмов для финансов (Financial Algorithms) на Python 💰📈

🔥 Финансовые алгоритмы помогают анализировать рынки, рассчитывать доходность и управлять рисками. Рассмотрим ключевые финансовые вычисления.

---

🔹 Пример 1: Расчет сложных процентов

def compound_interest(principal, rate, years):
    return principal * (1 + rate / 100) ** years

p = 1000  # Начальный вклад ($)
r = 5     # Годовая ставка (%)
t = 10    # Количество лет

print(f"Будущая стоимость: ${compound_interest(p, r, t):.2f}")

📌 *Полезно для расчета сбережений и инвестиций.*

---

🔹 Пример 2: Скользящее среднее (Moving Average) для анализа акций

import numpy as np

prices = [100, 102, 101, 105, 107, 110, 108]
window = 3  # Окно среднего

moving_avg = np.convolve(prices, np.ones(window)/window, mode='valid')
print("Скользящее среднее:", moving_avg)

📌 *Используется для сглаживания цен на акции и выявления трендов.*

---

🔹 Пример 3: Коэффициент Шарпа (Sharpe Ratio) для оценки риска

import numpy as np

returns = [0.02, 0.03, -0.01, 0.04, 0.05]  # Дневная доходность
risk_free_rate = 0.01

excess_returns = np.array(returns) - risk_free_rate
sharpe_ratio = np.mean(excess_returns) / np.std(excess_returns)

print("Sharpe Ratio:", sharpe_ratio)

📌 *Помогает сравнивать доходность инвестиций с учетом риска.*

---

🔹 Пример 4: Прогнозирование цен акций с линейной регрессией

import numpy as np
from sklearn.linear_model import LinearRegression

days = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)
prices = np.array([100, 102, 104, 108, 110])

model = LinearRegression().fit(days, prices)
future_price = model.predict([[6]])

print(f"Прогнозируемая цена на 6-й день: ${future_price[0]:.2f}")

📌 *Используется для предсказания будущих цен на основе трендов.*

---

🔹 Пример 5: Моделирование Монте-Карло для оценки риска портфеля

import numpy as np

np.random.seed(42)
simulations = 10000
mean_return = 0.07
std_dev = 0.15
years = 10
initial_investment = 10000

simulated_values = initial_investment * (1 + np.random.normal(mean_return, std_dev, simulations)) ** years
percentile_5 = np.percentile(simulated_values, 5)

print(f"Ожидаемая стоимость: ${np.mean(simulated_values):.2f}")
print(f"Наихудший сценарий (5-й перцентиль): ${percentile_5:.2f}")

📌 *Используется для оценки вероятных финансовых результатов.*

---

⚡ Где это применяется?
✅ Инвестиции и трейдинг 📊
✅ Оценка риска и доходности 📉
✅ Финансовое моделирование 📈

Подпишись 👉🏻 @KodduuPython 🤖

И очередной набор в группу курсы с преподавателями Профессия Data Scientist с нуля до Junior. Data Science это отдельная вселенная, надо прямо любить делать выводы из большого кол-ва данных, а Python изначально был сделал именно для таких целей 🔥🔥🔥

Реклама. Информация о рекламодателе по ссылкам в посте.

Итак, мы продолжаем создавать RAG (Retrieval Augmented Generation) систему для нашей компании. На этой неделе обсудили с Platform team текущую архитектуру и поняли, что нужно внедрять MCP Server. Да, мы пока делали без него 🤦

MCP будет работать с запросами пользователей, заниматься прояснением их намерений и направлять запросы к соответствующей системе знаний.

ЧИТАТЬ ДАЛЬШЕ В НОВОМ КАНАЛЕ 👉🏻👉🏻👉🏻 @aigentto 🤖🤖🤖

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

Вот пример Python-кода, который моделирует процесс декодирования сигнала, принимаемого с аппарата типа Voyager. Мы будем использовать следующие ключевые элементы:

1. Модуляция BPSK (Binary Phase Shift Keying): Это тип модуляции, используемый для передачи данных.
2. Код Хэмминга: Простой, но эффективный метод коррекции ошибок.
3. Добавление шума к сигналу: Моделирование влияния шума на сигнал.
4. Декодирование сигнала: Восстановление исходных данных после приема.

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import butter, lfilter

# Генерация случайных битов
def generate_data(num_bits):
    return np.random.randint(0, 2, num_bits)

# Кодирование Хэмминга (7,4)
def hamming_encode(data):
    encoded = []
    for i in range(0, len(data), 4):
        block = data[i:i+4]
        if len(block) < 4:
            block = np.pad(block, (0, 4 - len(block)), 'constant')
        p1 = (block[0] + block[1] + block[3]) % 2
        p2 = (block[0] + block[2] + block[3]) % 2
        p3 = (block[1] + block[2] + block[3]) % 2
        encoded.extend([p1, p2, block[0], p3, block[1], block[2], block[3]])
    return np.array(encoded)

# Декодирование Хэмминга (7,4)
def hamming_decode(received):
    decoded = []
    for i in range(0, len(received), 7):
        block = received[i:i+7]
        if len(block) < 7:
            break
        p1 = (block[0] + block[2] + block[4] + block[6]) % 2
        p2 = (block[1] + block[2] + block[5] + block[6]) % 2
        p3 = (block[3] + block[4] + block[5] + block[6]) % 2
        error_pos = p1 + 2*p2 + 4*p3
        if error_pos > 0 and error_pos <= 7:
            block[error_pos - 1] ^= 1
        decoded.extend([block[2], block[4], block[5], block[6]])
    return np.array(decoded)

# BPSK-модуляция
def bpsk_modulate(bits):
    return 2 * bits - 1

# BPSK-демодуляция
def bpsk_demodulate(signal):
    return (signal > 0).astype(int)

# Добавление гауссовского шума
def add_noise(signal, snr_db):
    snr = 10 ** (snr_db / 10)
    power = np.mean(signal ** 2)
    noise_power = power / snr
    noise = np.sqrt(noise_power) * np.random.randn(len(signal))
    return signal + noise

# Низкочастотный фильтр Баттерворта
def butter_lowpass_filter(data, cutoff, fs, order=2):
    nyq = 0.5 * fs
    normal_cutoff = cutoff / nyq
    b, a = butter(order, normal_cutoff, btype='low')
    return lfilter(b, a, data)

# Основной процесс
np.random.seed(42)
num_bits = 128
snr_db = 10
fs = 1000
cutoff = 300

# Генерация и кодирование
original_data = generate_data(num_bits)
encoded_data = hamming_encode(original_data)
modulated_signal = bpsk_modulate(encoded_data)
noisy_signal = add_noise(modulated_signal, snr_db)
filtered_signal = butter_lowpass_filter(noisy_signal, cutoff, fs)
demodulated_data = bpsk_demodulate(filtered_signal)
decoded_data = hamming_decode(demodulated_data)

# Сравнение
print("Original Data:", original_data)
print("Decoded Data :", decoded_data[:len(original_data)])
print("Match        :", np.array_equal(original_data, decoded_data[:len(original_data)]))

# Визуализация
plt.figure(figsize=(12, 8))

plt.subplot(4, 1, 1)
plt.title("Modulated Signal")
plt.plot(modulated_signal, label="Modulated", color="blue")
plt.grid(True)
plt.legend()

plt.subplot(4, 1, 2)
plt.title("Noisy Signal")
plt.plot(noisy_signal, label="Noisy", color="red")
plt.grid(True)
plt.legend()

plt.subplot(4, 1, 3)
plt.title("Filtered Signal")
plt.plot(filtered_signal, label="Filtered", color="green")
plt.grid(True)
plt.legend()

plt.subplot(4, 1, 4)
plt.title("Demodulated Data")
plt.plot(demodulated_data, label="Demodulated", drawstyle="steps-post")
plt.grid(True)
plt.legend()

plt.tight_layout()
plt.savefig("output_full.png", dpi=300)
plt.show()

Объяснение кода

1. Генерация данных:
- Создается массив случайных битов, которые будут передаваться.

2. Кодирование Хэмминга:
- Данные кодируются с использованием кода Хэмминга (7,4), который добавляет контрольные биты для обнаружения и исправления ошибок.

3. Модуляция BPSK:
- Биты преобразуются в аналоговый сигнал с использованием BPSK (0 -> -1, 1 -> 1).

4. Добавление шума:
- К сигналу добавляется гауссовский шум для моделирования реальных условий передачи.

5. Фильтрация сигнала:
- Низкочастотный фильтр используется для уменьшения шума.

6. Демодуляция BPSK:
- Аналоговый сигнал преобразуется обратно в цифровые биты.

7. Декодирование Хэмминга:
- Полученные биты декодируются, и исправляются возможные ошибки.

8. Визуализация:
- Показаны графики исходного сигнала, зашумленного сигнала, отфильтрованного сигнала и демодулированных данных.

Что можно улучшить?

1. Использование более сложных кодов:
- Например, сверточные коды или коды Рида-Соломона, которые используются в реальных системах связи.

2. Моделирование задержки сигнала:
- Учет времени прохождения сигнала через огромное расстояние.

3. Добавление эффектов Доплера:
- Учет изменения частоты сигнала из-за движения аппарата.

Этот код демонстрирует основные принципы работы с сигналами, принимаемыми с дальних космических аппаратов, таких как Voyager.

Подпишись 👉🏻 @KodduuPython 🤖

График кода выше 👆👆👆