task3_3.py - master - ku11ch/Lab_3

task3_3.py
143 строки6 KB
ku11ch
upload files
14 окт 2025, 10:54
14 окт 2025, 10:5424ce3ca
# correlation_code.py
# Корреляционный код

import numpy as np
import random


class CorrelationCode:
    def __init__(self, code_length=8, correlation_bits=4):
        self.code_length = code_length
        self.correlation_bits = correlation_bits
        self.correlation_matrix = self._generate_correlation_matrix()

    def _generate_correlation_matrix(self):
        """
        Генерация матрицы корреляции
        возвращает: матрицу корреляции
        """
        # Создаем случайную матрицу корреляции
        matrix = np.random.rand(self.code_length, self.correlation_bits)
        # Нормализуем матрицу
        matrix = matrix / np.linalg.norm(matrix, axis=1, keepdims=True)
        return matrix

    def encode(self, data):
        if len(data) != self.code_length:
            raise ValueError(f"Длина данных должна быть {self.code_length}")

        data_vector = np.array(data, dtype=float)
        correlation_code = np.dot(data_vector, self.correlation_matrix)
        return correlation_code

    def decode(self, correlation_code, threshold=0.5):
        # Используем псевдообратную матрицу для декодирования
        pseudo_inverse = np.linalg.pinv(self.correlation_matrix)
        decoded = np.dot(correlation_code, pseudo_inverse.T)

        # Бинаризация
        binary_data = [1 if x > threshold else 0 for x in decoded]
        return binary_data

    def introduce_errors(self, correlation_code, error_probability=0.1):
        corrupted_code = correlation_code.copy()

        for i in range(len(corrupted_code)):
            if random.random() < error_probability:
                # Добавляем шум
                noise = random.gauss(0, 0.5)
                corrupted_code[i] += noise

        return corrupted_code

    def calculate_detection_probability(self, data, error_probability=0.1, num_tests=1000):
        original_code = self.encode(data)
        detected_errors = 0
        total_tests = 0

        for _ in range(num_tests):
            # Вносим ошибки
            corrupted_code = self.introduce_errors(original_code, error_probability)

            # Декодируем
            decoded_data = self.decode(corrupted_code)

            # Сравниваем с исходными данными
            if decoded_data != data:
                detected_errors += 1

            total_tests += 1

        return detected_errors / total_tests if total_tests > 0 else 0.0

    def calculate_correlation(self, data1, data2):
        code1 = self.encode(data1)
        code2 = self.encode(data2)
        return np.corrcoef(code1, code2)[0, 1]


def demonstrate_correlation_code():
    """Демонстрация работы корреляционного кода"""
    print("=== Корреляционный код ===")

    # Создаем экземпляр кода
    correlation_code = CorrelationCode(code_length=8, correlation_bits=4)

    # Тестовые данные
    test_data = [1, 0, 1, 0, 1, 1, 0, 0]
    print(f"Исходные данные: {test_data}")

    # Кодирование
    encoded = correlation_code.encode(test_data)
    print(f"Корреляционный код: {encoded}")

    # Декодирование
    decoded = correlation_code.decode(encoded)
    print(f"Декодированные данные: {decoded}")
    print(f"Декодирование успешно: {decoded == test_data}")

    # Внесение ошибок
    corrupted = correlation_code.introduce_errors(encoded, error_probability=0.3)
    print(f"\nКод с ошибками: {corrupted}")

    # Декодирование с ошибками
    decoded_corrupted = correlation_code.decode(corrupted)
    print(f"Декодированные данные с ошибками: {decoded_corrupted}")
    print(f"Обнаружены ошибки: {decoded_corrupted != test_data}")

    # Коэффициент обнаружения ошибок
    detection_prob = correlation_code.calculate_detection_probability(test_data, 0.2, 500)
    print(f"\nКоэффициент обнаружения ошибок (p=0.2): {detection_prob:.4f}")

    # Исследование корреляционных свойств
    print("\nИсследование корреляционных свойств:")

    # Похожие данные
    similar_data1 = [1, 0, 1, 0, 1, 1, 0, 0]
    similar_data2 = [1, 0, 1, 0, 1, 1, 0, 1]  # отличается последний бит

    # Разные данные
    different_data = [0, 1, 0, 1, 0, 0, 1, 1]

    corr_similar = correlation_code.calculate_correlation(similar_data1, similar_data2)
    corr_different = correlation_code.calculate_correlation(similar_data1, different_data)

    print(f"Корреляция похожих данных: {corr_similar:.4f}")
    print(f"Корреляция разных данных: {corr_different:.4f}")

    # Влияние параметров на помехоустойчивость
    print("\nВлияние параметров на помехоустойчивость:")
    test_cases = [
        (8, 2), (8, 4), (8, 6),
        (16, 4), (16, 8)
    ]

    for length, corr_bits in test_cases:
        test_code = CorrelationCode(length, corr_bits)
        test_data = [random.randint(0, 1) for _ in range(length)]
        prob = test_code.calculate_detection_probability(test_data, 0.1, 200)
        print(f"Длина={length}, корреляционных бит={corr_bits}: обнаружение={prob:.4f}")


if __name__ == "__main__":
    demonstrate_correlation_code()