исправь этот код, чтобы он работал:
import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl
import pyshark
import threading
import time
from collections import defaultdict

# Определение нечетких переменных

# Скорость передачи сетевых пакетов (в пакетах в секунду)
packet_rate = ctrl.Antecedent(np.arange(0, 10001, 1), 'packet_rate')

# Количество уникальных IP адресов источников
unique_ips = ctrl.Antecedent(np.arange(0, 10001, 1), 'unique_ips')

# Количество запросов с одного IP
requests_per_ip = ctrl.Antecedent(np.arange(0, 10001, 1), 'requests_per_ip')

# Флаги пакетов (0-1, где 1 означает наличие подозрительных флагов)
packet_flags = ctrl.Antecedent(np.arange(0, 1.1, 0.1), 'packet_flags')

# Размер пакета (в байтах)
packet_size = ctrl.Antecedent(np.arange(0, 1501, 1), 'packet_size')

# Задержка в сети (в миллисекундах)
network_latency = ctrl.Antecedent(np.arange(0, 1001, 1), 'network_latency')

# Количество активных соединений
active_connections = ctrl.Antecedent(np.arange(0, 10001, 1), 'active_connections')

# Процент полуоткрытых соединений
half_open_connections = ctrl.Antecedent(np.arange(0, 101, 1), 'half_open_connections')

# Среднее время между пакетами (в миллисекундах)
avg_packet_interval = ctrl.Antecedent(np.arange(0, 1001, 1), 'avg_packet_interval')

# Объем трафика (в МБ за секунду)
traffic_volume = ctrl.Antecedent(np.arange(0, 1001, 1), 'traffic_volume')

# Процент неудачных попыток соединения
failed_connection_attempts = ctrl.Antecedent(np.arange(0, 101, 1), 'failed_connection_attempts')

# Скорость SYN-пакетов (в пакетах в секунду)
syn_rate = ctrl.Antecedent(np.arange(0, 10001, 1), 'syn_rate')

# Скорость UDP-пакетов (в пакетах в секунду)
udp_rate = ctrl.Antecedent(np.arange(0, 10001, 1), 'udp_rate')

# Скорость ICMP-пакетов (в пакетах в секунду)
icmp_rate = ctrl.Antecedent(np.arange(0, 10001, 1), 'icmp_rate')

# Использование полосы пропускания (в процентах)
bandwidth_usage = ctrl.Antecedent(np.arange(0, 101, 1), 'bandwidth_usage')

# Использование процессора сервера (в процентах)
cpu_usage = ctrl.Antecedent(np.arange(0, 101, 1), 'cpu_usage')

# Использование памяти сервера (в процентах)
memory_usage = ctrl.Antecedent(np.arange(0, 101, 1), 'memory_usage')

# Интенсивность атаки (Выходная переменная)
attack_intensity = ctrl.Consequent(np.arange(0, 101, 1), 'attack_intensity')

# Перегрузка сети (Выходная переменная)
network_overload = ctrl.Consequent(np.arange(0, 101, 1), 'network_overload')

# Перегрузка сервера (Выходная переменная)
server_overload = ctrl.Consequent(np.arange(0, 101, 1), 'server_overload')

# Определение функций принадлежности для входных нечетких переменных

# Функции принадлежности для скорости передачи сетевых пакетов
packet_rate['low'] = fuzz.trapmf(packet_rate.universe, [0, 0, 1000, 3000])
packet_rate['medium'] = fuzz.trimf(packet_rate.universe, [1000, 5000, 9000])
packet_rate['high'] = fuzz.trapmf(packet_rate.universe, [7000, 9000, 10000, 10000])

# Количество уникальных IP адресов источников
unique_ips['few'] = fuzz.trapmf(unique_ips.universe, [0, 0, 100, 500])
unique_ips['moderate'] = fuzz.trimf(unique_ips.universe, [100, 1000, 5000])
unique_ips['many'] = fuzz.trapmf(unique_ips.universe, [3000, 5000, 10000, 10000])

# Количество запросов с одного IP
requests_per_ip['normal'] = fuzz.trapmf(requests_per_ip.universe, [0, 0, 50, 100])
requests_per_ip['suspicious'] = fuzz.trimf(requests_per_ip.universe, [50, 500, 1000])
requests_per_ip['attack'] = fuzz.trapmf(requests_per_ip.universe, [800, 1000, 10000, 10000])

# Флаги пакетов
packet_flags['normal'] = fuzz.trimf(packet_flags.universe, [0, 0, 0.5])
packet_flags['anomalous'] = fuzz.trimf(packet_flags.universe, [0.4, 1, 1])

# Размер пакета
packet_size['small'] = fuzz.trapmf(packet_size.universe, [0, 0, 200, 400])
packet_size['medium'] = fuzz.trimf(packet_size.universe, [200, 600, 1000])
packet_size['large'] = fuzz.trapmf(packet_size.universe, [800, 1000, 1500, 1500])

# Задержка в сети
network_latency['low'] = fuzz.trapmf(network_latency.universe, [0, 0, 100, 300])
network_latency['medium'] = fuzz.trimf(network_latency.universe, [100, 500, 700])
network_latency['high'] = fuzz.trapmf(network_latency.universe, [500, 700, 1000, 1000])

# Количество активных соединений
active_connections['low'] = fuzz.trapmf(active_connections.universe, [0, 0, 100, 500])
active_connections['medium'] = fuzz.trimf(active_connections.universe, [100, 1000, 5000])
active_connections['high'] = fuzz.trapmf(active_connections.universe, [3000, 5000, 10000, 10000])

# Процент полуоткрытых соединений
half_open_connections['low'] = fuzz.trapmf(half_open_connections.universe, [0, 0, 10, 30])
half_open_connections['medium'] = fuzz.trimf(half_open_connections.universe, [10, 50, 70])
half_open_connections['high'] = fuzz.trapmf(half_open_connections.universe, [50, 70, 100, 100])

# Среднее время между пакетами
avg_packet_interval['short'] = fuzz.trapmf(avg_packet_interval.universe, [0, 0, 10, 50])
avg_packet_interval['medium'] = fuzz.trimf(avg_packet_interval.universe, [10, 200, 500])
avg_packet_interval['long'] = fuzz.trapmf(avg_packet_interval.universe, [300, 500, 1000, 1000])

# Объем трафика
traffic_volume['low'] = fuzz.trapmf(traffic_volume.universe, [0, 0, 100, 200])
traffic_volume['medium'] = fuzz.trimf(traffic_volume.universe, [100, 300, 500])
traffic_volume['high'] = fuzz.trapmf(traffic_volume.universe, [400, 600, 1000, 1000])

# Процент неудачных попыток соединения
failed_connection_attempts['low'] = fuzz.trapmf(failed_connection_attempts.universe, [0, 0, 10, 30])
failed_connection_attempts['medium'] = fuzz.trimf(failed_connection_attempts.universe, [10, 40, 70])
failed_connection_attempts['high'] = fuzz.trapmf(failed_connection_attempts.universe, [60, 80, 100, 100])

# Скорость SYN-пакетов
syn_rate['low'] = fuzz.trapmf(syn_rate.universe, [0, 0, 100, 500])
syn_rate['medium'] = fuzz.trimf(syn_rate.universe, [100, 1000, 5000])
syn_rate['high'] = fuzz.trapmf(syn_rate.universe, [3000, 5000, 10000, 10000])

# Скорость UDP-пакетов
udp_rate['low'] = fuzz.trapmf(udp_rate.universe, [0, 0, 100, 500])
udp_rate['medium'] = fuzz.trimf(udp_rate.universe, [100, 1000, 5000])
udp_rate['high'] = fuzz.trapmf(udp_rate.universe, [3000, 5000, 10000, 10000])

# Скорость ICMP-пакетов
icmp_rate['low'] = fuzz.trapmf(icmp_rate.universe, [0, 0, 10, 50])
icmp_rate['medium'] = fuzz.trimf(icmp_rate.universe, [10, 100, 500])
icmp_rate['high'] = fuzz.trapmf(icmp_rate.universe, [300, 500, 10000, 10000])

# Использование полосы пропускания
bandwidth_usage['low'] = fuzz.trapmf(bandwidth_usage.universe, [0, 0, 30, 50])
bandwidth_usage['medium'] = fuzz.trimf(bandwidth_usage.universe, [30, 50, 70])
bandwidth_usage['high'] = fuzz.trapmf(bandwidth_usage.universe, [50, 70, 100, 100])

# Использование процессора сервера
cpu_usage['low'] = fuzz.trapmf(cpu_usage.universe, [0, 0, 30, 50])
cpu_usage['medium'] = fuzz.trimf(cpu_usage.universe, [30, 50, 70])
cpu_usage['high'] = fuzz.trapmf(cpu_usage.universe, [50, 70, 100, 100])

# Использование памяти сервера
memory_usage['low'] = fuzz.trapmf(memory_usage.universe, [0, 0, 30, 50])
memory_usage['medium'] = fuzz.trimf(memory_usage.universe, [30, 50, 70])
memory_usage['high'] = fuzz.trapmf(memory_usage.universe, [50, 70, 100, 100])

# Функции принадлежности для выходных переменных

# Интенсивность атаки
attack_intensity['low'] = fuzz.trimf(attack_intensity.universe, [0, 0, 50])
attack_intensity['medium'] = fuzz.trimf(attack_intensity.universe, [20, 50, 80])
attack_intensity['high'] = fuzz.trimf(attack_intensity.universe, [50, 100, 100])

# Перегрузка сети
network_overload['low'] = fuzz.trimf(network_overload.universe, [0, 0, 50])
network_overload['medium'] = fuzz.trimf(network_overload.universe, [20, 50, 80])
network_overload['high'] = fuzz.trimf(network_overload.universe, [50, 100, 100])

# Перегрузка сервера
server_overload['low'] = fuzz.trimf(server_overload.universe, [0, 0, 50])
server_overload['medium'] = fuzz.trimf(server_overload.universe, [20, 50, 80])
server_overload['high'] = fuzz.trimf(server_overload.universe, [50, 100, 100])

# Определение правил нечеткой логики

# Правила для интенсивности атаки
rule1 = ctrl.Rule(packet_rate['high'] & unique_ips['many'], attack_intensity['high'])
rule2 = ctrl.Rule(requests_per_ip['attack'] & unique_ips['few'], attack_intensity['high'])
rule3 = ctrl.Rule(syn_rate['high'] & half_open_connections['high'], attack_intensity['high'])
rule4 = ctrl.Rule(udp_rate['high'] & packet_size['large'], attack_intensity['medium'])
rule5 = ctrl.Rule(icmp_rate['high'] & avg_packet_interval['short'], attack_intensity['medium'])
rule6 = ctrl.Rule(failed_connection_attempts['high'] & packet_flags['anomalous'], attack_intensity['high'])
rule11 = ctrl.Rule(packet_rate['low'] & unique_ips['few'], attack_intensity['low'])
rule12 = ctrl.Rule(udp_rate['low'] & icmp_rate['low'], attack_intensity['low'])
rule13 = ctrl.Rule(syn_rate['medium'], attack_intensity['medium'])
rule14 = ctrl.Rule(avg_packet_interval['long'], attack_intensity['low'])
rule15 = ctrl.Rule(half_open_connections['low'], attack_intensity['low'])
rule16 = ctrl.Rule(failed_connection_attempts['low'], attack_intensity['low'])
rule19 = ctrl.Rule(packet_flags['normal'], attack_intensity['low'])

# Правила для перегрузки сети
rule7 = ctrl.Rule(traffic_volume['high'] & network_latency['high'], network_overload['high'])
rule17 = ctrl.Rule(network_latency['low'], network_overload['low'])
rule20 = ctrl.Rule(traffic_volume['medium'] & network_latency['medium'], network_overload['medium'])
rule25 = ctrl.Rule(bandwidth_usage['high'], network_overload['high'])
rule26 = ctrl.Rule(bandwidth_usage['medium'], network_overload['medium'])
rule27 = ctrl.Rule(bandwidth_usage['low'], network_overload['low'])

# Правила для перегрузки сервера
rule18 = ctrl.Rule(active_connections['low'], server_overload['low'])
rule21 = ctrl.Rule(cpu_usage['high'] & memory_usage['high'], server_overload['high'])
rule22 = ctrl.Rule(cpu_usage['medium'] | memory_usage['medium'], server_overload['medium'])
rule23 = ctrl.Rule(active_connections['high'], server_overload['high'])
rule24 = ctrl.Rule(active_connections['medium'], server_overload['medium'])

# Создаем систему управления
ddos_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5, rule6, rule7,
                                rule11, rule12, rule13, rule14, rule15, rule16, rule17,
                                rule18, rule19, rule20, rule21, rule22, rule23,
                                rule24, rule25, rule26, rule27])

ddos_detection = ctrl.ControlSystemSimulation(ddos_ctrl)

# Устанавливаем размеры окна и интервалов
WINDOW_SIZE = 10  # Оконный интервал в секундах

# Основной цикл обработки
while True:
    # Инициализация переменных для сбора статистики
    packet_counts = []
    source_ips = defaultdict(int)
    dest_ips = defaultdict(int)
    packet_sizes = []
    packet_intervals = []
    syn_packets = 0
    udp_packets = 0
    icmp_packets = 0
    half_open_conn = 0
    failed_conn_attempts = 0
    anomalous_flags = 0
    traffic_volume_total = 0
    last_packet_time = None

    start_time = time.time()

    # Используем pyshark для захвата пакетов в течение WINDOW_SIZE секунд
    capture = pyshark.LiveCapture(interface='vEthernet (vEthernet)')  # Укажите свой сетевой интерфейс
    capture.sniff(timeout=WINDOW_SIZE)

    duration = time.time() - start_time
    if duration == 0:
        duration = 1  # чтобы избежать деления на ноль

    # Обработка каждого пакета
    for pkt in capture:
        curr_time = float(pkt.sniff_timestamp)

        # Подсчитываем общее количество пакетов
        packet_counts.append(1)

        # Подсчитываем объем трафика
        length = int(pkt.length)
        traffic_volume_total += length
        packet_sizes.append(length)

        # Временные интервалы между пакетами
        if last_packet_time is not None:
            interval = (curr_time - last_packet_time) * 1000  # в миллисекундах
            packet_intervals.append(interval)
        last_packet_time = curr_time

        # Обработка IP
        if hasattr(pkt, 'ip'):
            src_ip = pkt.ip.src
            dst_ip = pkt.ip.dst
            source_ips[src_ip] += 1
            dest_ips[dst_ip] += 1

        # Обработка протоколов и флагов
        if hasattr(pkt, 'tcp'):
            # Проверяем флаги TCP
            flags = pkt.tcp.flags
            # Проверяем на SYN-флаг
            if '0x0002' in flags:
                syn_packets += 1
            # Проверяем на полуоткрытые соединения
            if '0x0002' in flags and not '0x0012' in flags:  # SYN без ACK
                half_open_conn += 1

            # Проверяем на аномальные флаги (например, установлены SYN и FIN одновременно)
            if '0x0002' in flags and '0x0001' in flags:
                anomalous_flags += 1

            # Проверяем неудачные попытки соединения (RST-флаг)
            if '0x0004' in flags:
                failed_conn_attempts += 1

        elif hasattr(pkt, 'udp'):
            udp_packets += 1

        elif hasattr(pkt, 'icmp'):
            icmp_packets += 1

    total_packets = sum(packet_counts)

    # Если пакетов нет, пропускаем текущую итерацию
    if total_packets == 0:
        print("Нет пакетов для обработки в этом окне.")
        print("------------")
        continue

    # Рассчитываем метрики за период окна

    # Скорость передачи пакетов
    packet_rate_value = total_packets / duration

    # Количество уникальных IP источников
    unique_ips_value = len(source_ips)

    # Количество запросов с одного IP (берем максимальное значение)
    if source_ips:
        requests_per_ip_value = max(source_ips.values())
    else:
        requests_per_ip_value = 0

    # Процент аномальных флагов
    packet_flags_value = anomalous_flags / total_packets

    # Средний размер пакета
    packet_size_value = sum(packet_sizes) / len(packet_sizes)

    # Среднее время между пакетами
    if packet_intervals:
        avg_packet_interval_value = sum(packet_intervals) / len(packet_intervals)
    else:
        avg_packet_interval_value = 0

    # Процент полуоткрытых соединений
    if syn_packets > 0:
        half_open_connections_value = (half_open_conn / syn_packets) * 100
    else:
        half_open_connections_value = 0

    # Объем трафика в МБ за секунду
    traffic_volume_value = (traffic_volume_total / duration) / (1024 * 1024)

    # Процент неудачных попыток соединения
    failed_connection_attempts_value = (failed_conn_attempts / total_packets) * 100

    # Скорость SYN-пакетов
    syn_rate_value = syn_packets / duration

    # Скорость UDP-пакетов
    udp_rate_value = udp_packets / duration

    # Скорость ICMP-пакетов
    icmp_rate_value = icmp_packets / duration

    # Использование полосы пропускания
    # Предположим, что максимальная полоса пропускания 100 Мбит/с
    max_bandwidth = 100 * 1024 * 1024 / 8  # в байтах в секунду
    bandwidth_usage_value = ((traffic_volume_total / duration) / max_bandwidth) * 100

    # Использование CPU и памяти сервера
    # Для реальных данных можно использовать библиотеку psutil
    # import psutil
    # cpu_usage_value = psutil.cpu_percent()
    # memory_usage_value = psutil.virtual_memory().percent

    # Для примера используем фиктивные значения:
    cpu_usage_value = 50  # Замените на реальные данные
    memory_usage_value = 40  # Замените на реальные данные

    # Вводим значения в систему нечеткой логики
    ddos_detection.input['packet_rate'] = packet_rate_value
    ddos_detection.input['unique_ips'] = unique_ips_value
    ddos_detection.input['requests_per_ip'] = requests_per_ip_value
    ddos_detection.input['packet_flags'] = packet_flags_value
    ddos_detection.input['packet_size'] = packet_size_value
    ddos_detection.input['avg_packet_interval'] = avg_packet_interval_value
    ddos_detection.input['half_open_connections'] = half_open_connections_value
    ddos_detection.input['traffic_volume'] = traffic_volume_value
    ddos_detection.input['failed_connection_attempts'] = failed_connection_attempts_value
    ddos_detection.input['syn_rate'] = syn_rate_value
    ddos_detection.input['udp_rate'] = udp_rate_value
    ddos_detection.input['icmp_rate'] = icmp_rate_value
    ddos_detection.input['bandwidth_usage'] = bandwidth_usage_value
    ddos_detection.input['cpu_usage'] = cpu_usage_value
    ddos_detection.input['memory_usage'] = memory_usage_value

    try:
        ddos_detection.compute()
    except Exception as e:
        print(f"Ошибка при вычислении нечеткой логики: {e}")
        continue  # Пропускаем текущую итерацию

    # Выводим результаты
    print("Результаты за последние {} секунд:".format(WINDOW_SIZE))
    print(f"Интенсивность атаки: {ddos_detection.output['attack_intensity']:.2f}%")
    print(f"Перегрузка сети: {ddos_detection.output['network_overload']:.2f}%")
    print(f"Перегрузка сервера: {ddos_detection.output['server_overload']:.2f}%")
    print("------------")