Вот код системы нечеткой логики: import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl
import matplotlib.pyplot as plt

# Определение входных переменных

# 1. Скорость входящего трафика
traffic_rate = ctrl.Antecedent(np.arange(0, 10001, 1), 'traffic_rate')  # Пакеты в секунду

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

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

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

# 5. Процент аномальных размеров пакетов
anomalous_packet = ctrl.Antecedent(np.arange(0, 101, 1), 'anomalous_packet')  # %

# 6. Количество запросов к одному ресурсу
requests_per_resource = ctrl.Antecedent(np.arange(0, 10001, 1), 'requests_per_resource')  # Запросов

# 7. Вариация размера пакетов
packet_size_variance = ctrl.Antecedent(np.arange(0, 101, 1), 'packet_size_variance')  # %

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

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

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

# 11. Процент новых соединений
new_conn_percent = ctrl.Antecedent(np.arange(0, 101, 1), 'new_conn_percent')  # %

# 12. Загрузка CPU
cpu_usage = ctrl.Antecedent(np.arange(0, 101, 1), 'cpu_usage')  # %

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

# 14. Вариация длительности соединений
conn_duration_variance = ctrl.Antecedent(np.arange(0, 101, 1), 'conn_duration_variance')  # %

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

# 16. Частота ошибок пакетов
error_rate = ctrl.Antecedent(np.arange(0, 101, 1), 'error_rate')  # %

# 17. Количество протокольных аномалий
protocol_anomalies = ctrl.Antecedent(np.arange(0, 1001, 1), 'protocol_anomalies')  # Количество

# 18. Активность на критических портах
critical_port_activity = ctrl.Antecedent(np.arange(0, 10001, 1), 'critical_port_activity')  # Количество обращений

# 19. Отношение входящего к исходящему трафику
in_out_ratio = ctrl.Antecedent(np.arange(0, 11, 0.1), 'in_out_ratio')  # Отношение

# 20. Необычное использование протоколов
unusual_protocol_usage = ctrl.Antecedent(np.arange(0, 101, 1), 'unusual_protocol_usage')  # %

# Определение выходной переменной
ddos_risk = ctrl.Consequent(np.arange(0, 101, 1), 'ddos_risk')  # %

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

# 1. Скорость входящего трафика
traffic_rate['low'] = fuzz.trapmf(traffic_rate.universe, [0, 0, 1000, 3000])
traffic_rate['medium'] = fuzz.trimf(traffic_rate.universe, [2000, 5000, 8000])
traffic_rate['high'] = fuzz.trapmf(traffic_rate.universe, [7000, 9000, 10000, 10000])

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

# 3. Среднее время между пакетами
inter_arrival_time['long'] = fuzz.trapmf(inter_arrival_time.universe, [30, 50, 100, 100])
inter_arrival_time['average'] = fuzz.trimf(inter_arrival_time.universe, [10, 30, 50])
inter_arrival_time['short'] = fuzz.trapmf(inter_arrival_time.universe, [0, 0, 10, 20])

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

# 5. Процент аномальных размеров пакетов
anomalous_packet['normal'] = fuzz.trapmf(anomalous_packet.universe, [0, 0, 5, 15])
anomalous_packet['elevated'] = fuzz.trimf(anomalous_packet.universe, [10, 30, 50])
anomalous_packet['high'] = fuzz.trapmf(anomalous_packet.universe, [40, 60, 100, 100])

# 6. Количество запросов к одному ресурсу
requests_per_resource['low'] = fuzz.trapmf(requests_per_resource.universe, [0, 0, 1000, 3000])
requests_per_resource['medium'] = fuzz.trimf(requests_per_resource.universe, [2000, 5000, 8000])
requests_per_resource['high'] = fuzz.trapmf(requests_per_resource.universe, [7000, 9000, 10000, 10000])

# 7. Вариация размера пакетов
packet_size_variance['low'] = fuzz.trapmf(packet_size_variance.universe, [0, 0, 10, 30])
packet_size_variance['medium'] = fuzz.trimf(packet_size_variance.universe, [20, 50, 80])
packet_size_variance['high'] = fuzz.trapmf(packet_size_variance.universe, [70, 90, 100, 100])

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

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

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

# 11. Процент новых соединений
new_conn_percent['low'] = fuzz.trapmf(new_conn_percent.universe, [0, 0, 10, 30])
new_conn_percent['medium'] = fuzz.trimf(new_conn_percent.universe, [20, 50, 80])
new_conn_percent['high'] = fuzz.trapmf(new_conn_percent.universe, [70, 90, 100, 100])

# 12. Загрузка CPU
cpu_usage['low'] = fuzz.trapmf(cpu_usage.universe, [0, 0, 20, 40])
cpu_usage['medium'] = fuzz.trimf(cpu_usage.universe, [30, 50, 70])
cpu_usage['high'] = fuzz.trapmf(cpu_usage.universe, [60, 80, 100, 100])

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

# 14. Вариация длительности соединений
conn_duration_variance['low'] = fuzz.trapmf(conn_duration_variance.universe, [0, 0, 10, 30])
conn_duration_variance['medium'] = fuzz.trimf(conn_duration_variance.universe, [20, 50, 80])
conn_duration_variance['high'] = fuzz.trapmf(conn_duration_variance.universe, [70, 90, 100, 100])

# 15. Количество полуоткрытых соединений
half_open_conn['low'] = fuzz.trapmf(half_open_conn.universe, [0, 0, 1000, 3000])
half_open_conn['medium'] = fuzz.trimf(half_open_conn.universe, [2000, 5000, 8000])
half_open_conn['high'] = fuzz.trapmf(half_open_conn.universe, [7000, 9000, 10000, 10000])

# 16. Частота ошибок пакетов
error_rate['low'] = fuzz.trapmf(error_rate.universe, [0, 0, 10, 30])
error_rate['medium'] = fuzz.trimf(error_rate.universe, [20, 50, 80])
error_rate['high'] = fuzz.trapmf(error_rate.universe, [70, 90, 100, 100])

# 17. Количество протокольных аномалий
protocol_anomalies['low'] = fuzz.trapmf(protocol_anomalies.universe, [0, 0, 10, 30])
protocol_anomalies['medium'] = fuzz.trimf(protocol_anomalies.universe, [20, 50, 80])
protocol_anomalies['high'] = fuzz.trapmf(protocol_anomalies.universe, [70, 90, 1000, 1000])

# 18. Активность на критических портах
critical_port_activity['low'] = fuzz.trapmf(critical_port_activity.universe, [0, 0, 100, 300])
critical_port_activity['medium'] = fuzz.trimf(critical_port_activity.universe, [200, 500, 800])
critical_port_activity['high'] = fuzz.trapmf(critical_port_activity.universe, [700, 900, 10000, 10000])

# 19. Отношение входящего к исходящему трафику
in_out_ratio['low'] = fuzz.trapmf(in_out_ratio.universe, [0, 0, 0.5, 1.5])
in_out_ratio['balanced'] = fuzz.trimf(in_out_ratio.universe, [1, 2.5, 4])
in_out_ratio['high'] = fuzz.trapmf(in_out_ratio.universe, [3.5, 5, 10, 10])

# 20. Необычное использование протоколов
unusual_protocol_usage['normal'] = fuzz.trapmf(unusual_protocol_usage.universe, [0, 0, 5, 15])
unusual_protocol_usage['elevated'] = fuzz.trimf(unusual_protocol_usage.universe, [10, 30, 50])
unusual_protocol_usage['high'] = fuzz.trapmf(unusual_protocol_usage.universe, [40, 60, 100, 100])

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

ddos_risk['low'] = fuzz.trapmf(ddos_risk.universe, [0, 0, 20, 40])
ddos_risk['medium'] = fuzz.trimf(ddos_risk.universe, [30, 50, 70])
ddos_risk['high'] = fuzz.trapmf(ddos_risk.universe, [60, 80, 100, 100])

# Список всех переменных для удобства визуализации
variables = [traffic_rate, unique_ips, inter_arrival_time, failed_conn, anomalous_packet,
             requests_per_resource, packet_size_variance, syn_rate, udp_rate, icmp_rate,
             new_conn_percent, cpu_usage, memory_usage, conn_duration_variance,
             half_open_conn, error_rate, protocol_anomalies, critical_port_activity,
             in_out_ratio, unusual_protocol_usage, ddos_risk]

for var in variables:
    var.view()

plt.show()

# Примеры правил

rule1 = ctrl.Rule(
    traffic_rate['high'] &
    unique_ips['many'] &
    inter_arrival_time['short'] &
    failed_conn['high'] &
    anomalous_packet['high'] &
    requests_per_resource['high'] &
    syn_rate['high'] &
    half_open_conn['high'] &
    cpu_usage['high'] &
    error_rate['high'],
    ddos_risk['high'])

rule2 = ctrl.Rule(
    udp_rate['high'] &
    protocol_anomalies['high'] &
    unusual_protocol_usage['high'],
    ddos_risk['high'])

rule3 = ctrl.Rule(
    traffic_rate['medium'] &
    unique_ips['moderate'] &
    inter_arrival_time['average'] &
    failed_conn['medium'] &
    syn_rate['medium'] &
    cpu_usage['medium'] &
    memory_usage['medium'],
    ddos_risk['medium'])

rule4 = ctrl.Rule(
    traffic_rate['low'] &
    unique_ips['few'] &
    inter_arrival_time['long'] &
    failed_conn['low'] &
    anomalous_packet['normal'] &
    cpu_usage['low'] &
    memory_usage['low'],
    ddos_risk['low'])

rule5 = ctrl.Rule(
    icmp_rate['high'] &
    protocol_anomalies['medium'] &
    unusual_protocol_usage['elevated'],
    ddos_risk['medium'])

rule6 = ctrl.Rule(
    in_out_ratio['high'],
    ddos_risk['high'])

rule7 = ctrl.Rule(
    critical_port_activity['high'],
    ddos_risk['high'])

rule8 = ctrl.Rule(
    conn_duration_variance['high'] &
    packet_size_variance['high'],
    ddos_risk['high'])

rule9 = ctrl.Rule(
    cpu_usage['high'] &
    memory_usage['high'],
    ddos_risk['high'])

rule10 = ctrl.Rule(
    new_conn_percent['high'] &
    traffic_rate['high'],
    ddos_risk['high'])

# Добавьте дополнительные правила при необходимости

rules = [rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9, rule10]

# Создание системы управления
ddos_ctrl = ctrl.ControlSystem(rules)

# Создание симуляции
ddos_simulation = ctrl.ControlSystemSimulation(ddos_ctrl)



# Ввод значений для всех входных переменных (пример с высокой вероятностью атаки)

ddos_simulation.input['traffic_rate'] = 9500
ddos_simulation.input['unique_ips'] = 4500
ddos_simulation.input['inter_arrival_time'] = 5
ddos_simulation.input['failed_conn'] = 85
ddos_simulation.input['anomalous_packet'] = 80
ddos_simulation.input['requests_per_resource'] = 9000
ddos_simulation.input['packet_size_variance'] = 90
ddos_simulation.input['syn_rate'] = 9500
ddos_simulation.input['udp_rate'] = 8000
ddos_simulation.input['icmp_rate'] = 9000
ddos_simulation.input['new_conn_percent'] = 95
ddos_simulation.input['cpu_usage'] = 95
ddos_simulation.input['memory_usage'] = 90
ddos_simulation.input['conn_duration_variance'] = 85
ddos_simulation.input['half_open_conn'] = 9500
ddos_simulation.input['error_rate'] = 90
ddos_simulation.input['protocol_anomalies'] = 950
ddos_simulation.input['critical_port_activity'] = 9000
ddos_simulation.input['in_out_ratio'] = 8
ddos_simulation.input['unusual_protocol_usage'] = 85

# Вычисление
ddos_simulation.compute()

print(f"Риск DDoS-атаки: {ddos_simulation.output['ddos_risk']:.2f}%")

# Визуализация результата
ddos_risk.view(sim=ddos_simulation)
plt.show()

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