use tokio::net::{TcpListener, TcpStream};
use tokio::sync::{mpsc, Mutex};
use std::sync::Arc;
use std::collections::HashMap;
use std::time::{Duration, Instant};

// 串流工作階段狀態
struct StreamSession {
    client_id: String,
    last_activity: Instant,
    bitrate: u32,  // kbps
    stream_type: StreamType,
}

enum StreamType {
    RTMP,
    WebRTC,
    HLS,
}

// 全域串流管理器
struct StreamManager {
    sessions: HashMap<String, StreamSession>,
}

impl StreamManager {
    // 註冊新串流工作階段
    async fn register_stream(&mut self, client_id: String, stream_type: StreamType) {
        let session = StreamSession {
            client_id: client_id.clone(),
            last_activity: Instant::now(),
            bitrate: 2000,  // 預設2Mbps
            stream_type,
        };
        self.sessions.insert(client_id, session);
    }
    
    // 移除過期工作階段
    async fn cleanup_stale_sessions(&mut self) {
        let now = Instant::now();
        self.sessions.retain(|_, session| {
            now.duration_since(session.last_activity) < Duration::from_secs(30)
        });
    }
}

// 處理單一客戶端連線
async fn handle_client(
    stream: TcpStream, 
    manager: Arc<Mutex<StreamManager>>,
    client_id: String
) {
    let (read_half, write_half) = tokio::io::split(stream);
    
    // 建立通訊通道
    let (tx, mut rx) = mpsc::channel(100);
    
    // 註冊串流
    {
        let mut manager = manager.lock().await;
        manager.register_stream(client_id.clone(), StreamType::WebRTC).await;
    }
    
    // 接收資料並處理
    tokio::spawn(async move {
        // 讀取串流資料的實作
        // ...
    });
    
    // 處理傳送佇列
    while let Some(packet) = rx.recv().await {
        // 將資料寫回客戶端
        // ...
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化串流管理器
    let stream_manager = Arc::new(Mutex::new(StreamManager {
        sessions: HashMap::new(),
    }));
    
    // 啟動清理過期工作階段的背景任務
    let manager_clone = Arc::clone(&stream_manager);
    tokio::spawn(async move {
        let mut interval = tokio::time::interval(Duration::from_secs(5));
        loop {
            interval.tick().await;
            let mut manager = manager_clone.lock().await;
            manager.cleanup_stale_sessions().await;
        }
    });
    
    // 設定監聽器
    let listener = TcpListener::bind("0.0.0.0:1935").await?;
    println!("串流伺服器啟動於 0.0.0.0:1935");
    
    // 接受連線並分派處理
    let mut connection_counter = 0;
    while let Ok((stream, addr)) = listener.accept().await {
        connection_counter += 1;
        let client_id = format!("client-{}", connection_counter);
        println!("新連線來自: {}, 分配ID: {}", addr, client_id);
        
        let manager_clone = Arc::clone(&stream_manager);
        tokio::spawn(async move {
            if let Err(e) = handle_client(stream, manager_clone, client_id).await {
                eprintln!("處理客戶端時發生錯誤: {}", e);
            }
        });
    }
    
    Ok(())
}

use tokio::sync::mpsc;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// WebRTC訊號類別
#[derive(Serialize, Deserialize, Debug)]
enum SignalMessage {
    Offer { sdp: String },
    Answer { sdp: String },
    IceCandidate { candidate: String, sdp_mid: String },
    Leave,
}

// 處理WebRTC訊號交換
async fn handle_webrtc_signaling(
    peer_id: String,
    mut signal_rx: mpsc::Receiver<SignalMessage>,
    signal_tx: mpsc::Sender<SignalMessage>,
    peers: Arc<Mutex<HashMap<String, mpsc::Sender<SignalMessage>>>>
) {
    // 註冊此對等連線
    {
        let mut peers_map = peers.lock().await;
        peers_map.insert(peer_id.clone(), signal_tx.clone());
    }
    
    // 清理函式
    let peers_clone = Arc::clone(&peers);
    let peer_id_clone = peer_id.clone();
    let cleanup = async move {
        let mut peers_map = peers_clone.lock().await;
        peers_map.remove(&peer_id_clone);
        println!("對等連線 {} 已斷開", peer_id_clone);
    };
    
    // 確保在函式結束時執行清理
    tokio::spawn(async move {
        while let Some(msg) = signal_rx.recv().await {
            match msg {
                SignalMessage::Offer { sdp } => {
                    println!("收到來自 {} 的Offer", peer_id);
                    // 處理offer邏輯...
                },
                SignalMessage::Answer { sdp } => {
                    println!("收到來自 {} 的Answer", peer_id);
                    // 處理answer邏輯...
                },
                SignalMessage::IceCandidate { candidate, sdp_mid } => {
                    println!("收到來自 {} 的ICE候選項", peer_id);
                    // 處理ICE候選項邏輯...
                },
                SignalMessage::Leave => {
                    println!("對等連線 {} 請求離開", peer_id);
                    break;
                }
            }
        }
        
        cleanup.await;
    });
}

use rayon::prelude::*;
use image::{ImageBuffer, Rgb};
use std::time::Instant;

// 影片幀結構
struct VideoFrame {
    width: u32,
    height: u32,
    data: Vec<u8>,  // RGB格式，每個畫素3個位元組
}

impl VideoFrame {
    // 建立新的影片幀
    fn new(width: u32, height: u32) -> Self {
        let size = (width * height * 3) as usize;
        VideoFrame {
            width,
            height,
            data: vec![0; size],
        }
    }
    
    // 將RGB資料轉換為ImageBuffer以便處理
    fn to_image_buffer(&self) -> ImageBuffer<Rgb<u8>, Vec<u8>> {
        ImageBuffer::from_raw(self.width, self.height, self.data.clone())
            .expect("無法從資料建立影像緩衝區")
    }
    
    // 從ImageBuffer更新RGB資料
    fn from_image_buffer(&mut self, buffer: ImageBuffer<Rgb<u8>, Vec<u8>>) {
        self.data = buffer.into_raw();
    }
}

// 套用銳利化濾鏡（使用簡單的卷積核）
fn apply_sharpen_filter(frame: &mut VideoFrame) {
    let kernel: [[f32; 3]; 3] = [
        [ 0.0, -1.0,  0.0],
        [-1.0,  5.0, -1.0],
        [ 0.0, -1.0,  0.0]
    ];
    
    let mut img = frame.to_image_buffer();
    let width = frame.width;
    let height = frame.height;
    
    // 建立輸出影像
    let mut output = ImageBuffer::new(width, height);
    
    // 平行處理每個畫素
    (1..height-1).into_par_iter().for_each(|y| {
        for x in 1..width-1 {
            let mut r_sum = 0.0;
            let mut g_sum = 0.0;
            let mut b_sum = 0.0;
            
            // 應用卷積核
            for ky in 0..3 {
                for kx in 0..3 {
                    let pixel = img.get_pixel(x + kx - 1, y + ky - 1);
                    let weight = kernel[ky][kx];
                    
                    r_sum += pixel[0] as f32 * weight;
                    g_sum += pixel[1] as f32 * weight;
                    b_sum += pixel[2] as f32 * weight;
                }
            }
            
            // 確保值在有效範圍內
            let r = r_sum.clamp(0.0, 255.0) as u8;
            let g = g_sum.clamp(0.0, 255.0) as u8;
            let b = b_sum.clamp(0.0, 255.0) as u8;
            
            output.put_pixel(x, y, Rgb([r, g, b]));
        }
    });
    
    // 更新原始幀
    frame.from_image_buffer(output);
}

// 批次處理多個幀
fn process_video_frames(frames: &mut [VideoFrame]) {
    let start = Instant::now();
    
    // 平行處理所有幀
    frames.par_iter_mut().for_each(|frame| {
        apply_sharpen_filter(frame);
    });
    
    let duration = start.elapsed();
    println!("處理 {} 幀影片耗時: {:?}", frames.len(), duration);
}

// 用法範例
fn main() {
    // 模擬10幀4K影片
    let mut frames = Vec::new();
    for _ in 0..10 {
        frames.push(VideoFrame::new(3840, 2160));
    }
    
    // 平行處理所有幀
    process_

use quiche::{Config, Connection};
use std::net::UdpSocket;

fn setup_quic_server() -> Connection {
    let config = Config::new(quiche::PROTOCOL_VERSION).unwrap();
    let socket = UdpSocket::bind("0.0.0.0:4433").unwrap();
    
    quiche::accept(&mut socket, &config).unwrap()
}

#[global_allocator]
static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;

fn allocate_video_buffer(size: usize) -> Vec<u8> {
    vec![0; size] // 使用mimalloc高效分配
}

struct FramePool {
    buffers: Vec<Vec<u8>>,
    frame_size: usize,
    available: Vec<usize>,
}

impl FramePool {
    fn new(capacity: usize, frame_size: usize) -> Self {
        let mut buffers = Vec::with_capacity(capacity);
        let mut available = Vec::with_capacity(capacity);
        
        for i in 0..capacity {
            buffers.push(vec![0; frame_size]);
            available.push(i);
        }
        
        FramePool { buffers, frame_size, available }
    }
    
    fn get_buffer(&mut self) -> Option<&mut Vec<u8>> {
        self.available.pop().map(|idx| &mut self.buffers[idx])
    }
    
    fn return_buffer(&mut self, buffer: &mut Vec<u8>) {
        let idx = self.buffers.iter().position(|b| b.as_ptr() == buffer.as_ptr()).unwrap();
        self.available.push(idx);
    }
}

use bumpalo::Bump;

struct VideoFrame<'a> {
    data: &'a [u8],
}

fn process_video_frames() {
    let allocator = Bump::new();
    
    for _ in 0..100 {
        let frame_data = allocator.alloc_slice_copy(&[0u8; 4096]); // 分配視訊幀緩衝區
        let frame = VideoFrame { data: frame_data };
        analyze_frame(&frame);
    }
}

fn analyze_frame(frame: &VideoFrame) {
    // 對幀進行即時處理
}

use std::sync::Arc;
use tokio::task;

struct Frame {
    buffer: Arc<Vec<u8>>,
}

async fn process_frame(frame: Arc<Frame>) {
    // 不複製緩衝區的情況下進行非同步處理
}

#[tokio::main]
async fn main() {
    let buffer = Arc::new(vec![255; 4096]); // 大型視訊緩衝區
    let frame = Arc::new(Frame { buffer });

    let task1 = task::spawn(process_frame(frame.clone()));
    let task2 = task::spawn(process_frame(frame.clone()));

    task1.await.unwrap();
    task2.await.unwrap();
}

use pyo3::prelude::*;
use pyo3::wrap_pyfunction;

#[pyfunction]
fn process_video_frame(py: Python, frame_data: &[u8]) -> PyResult<Vec<u8>> {
    // 在Rust中進行高效的前處理
    let processed_data = preprocess_frame(frame_data);
    Ok(processed_data)
}

fn preprocess_frame(frame_data: &[u8]) -> Vec<u8> {
    // 實作高效的影片幀前處理邏輯
    frame_data.to_vec() // 簡化範例
}

#[pymodule]
fn rust_video_processor(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(process_video_frame, m)?)?;
    Ok(())
}

import numpy as np
import torch
from rust_video_processor import process_video_frame

def enhance_video_frame(frame):
    # 將NumPy陣列轉換為位元組
    frame_bytes = frame.tobytes()
    
    # 使用Rust進行高效預處理
    processed_bytes = process_video_frame(frame_bytes)
    
    # 轉回NumPy陣列
    processed_frame = np.frombuffer(processed_bytes, dtype=np.uint8).reshape(frame.shape)
    
    # 使用PyTorch模型進行AI增強
    tensor = torch.from_numpy(processed_frame).float() / 255.0
    enhanced_tensor = ai_model(tensor)
    
    return enhanced_tensor.numpy() * 255

use pyo3::prelude::*;
use bumpalo::Bump;

#[pyclass]
struct FramePool {
    allocator: Bump,
}

#[pymethods]
impl FramePool {
    #[new]
    fn new() -> Self {
        FramePool { allocator: Bump::new() }
    }

    fn allocate_frame(&self, size: usize) -> PyResult<Vec<u8>> {
        let frame = self.allocator.alloc_slice_fill_default(size);
        Ok(frame.to_vec())
    }
}

#[pymodule]
fn rust_memory(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_class::<FramePool>()?;
    Ok(())
}

import rust_memory

pool = rust_memory.FramePool()
frame = pool.allocate_frame(4096)

fn apply_brightness_scalar(pixels: &mut [u8], adjustment: u8) {
    for pixel in pixels.iter_mut() {
        *pixel = (*pixel).saturating_add(adjustment);
    }
}

use std::simd::{u8x16, Simd};

fn apply_brightness_simd(pixels: &mut [u8], adjustment: u8) {
    let adjustment_vec = u8x16::splat(adjustment);
    let len = pixels.len();
    
    let chunks = len / 16;
    let remainder = len % 16;

    let pixel_simd = pixels.as_mut_ptr() as *mut u8x16;
    
    for i in 0..chunks {
        unsafe {
            let mut data = *pixel_simd.add(i);
            data += adjustment_vec;
            *pixel_simd.add(i) = data;
        }
    }
    
    for i in len - remainder..len {
        pixels[i] = pixels[i].saturating_add(adjustment);
    }
}

#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;

unsafe fn apply_brightness_avx(pixels: &mut [u8], adjustment: u8) {
    let adjustment_vec = _mm_set1_epi8(adjustment as i8);
    let len = pixels.len();
    
    let chunks = len / 32;
    let remainder = len % 32;
    
    let pixel_avx = pixels.as_mut_ptr() as *mut __m256i;

    for i in 0..chunks {
        let mut data = _mm256_loadu_si256(pixel_avx.add(i));
        data = _mm256_add_epi8(data, adjustment_vec);
        _mm256_storeu_si256(pixel_avx.add(i), data);
    }
    
    for i in len - remainder..len {
        pixels[i] = pixels[i].saturating_add(adjustment);
    }
}

#[cfg(target_arch = "aarch64")]
use std::arch::aarch64::*;

unsafe fn apply_brightness_neon(pixels: &mut [u8], adjustment: u8) {
    let adjustment_vec = vdupq_n_u8(adjustment);
    let len = pixels.len();

    let chunks = len / 16;
    let remainder = len % 16;

    let pixel_neon = pixels.as_mut_ptr() as *mut uint8x16_t;

    for i in 0..chunks {
        let mut data = vld1q_u8(pixel_neon.add(i));
        data = vaddq_u8(data, adjustment_vec);
        vst1q_u8(pixel_neon.add(i), data);
    }

    for i in len - remainder..len {
        pixels[i] = pixels[i].saturating_add(adjustment);
    }
}

fn apply_brightness(pixels: &mut [u8], adjustment: u8) {
    #[cfg(target_arch = "x86_64")]
    {
        if is_x86_feature_detected!("avx2") {
            unsafe { return apply_brightness_avx(pixels, adjustment); }
        }
    }
    
    #[cfg(target_arch = "aarch64")]
    {
        if is_aarch64_feature_detected!("neon") {
            unsafe { return apply_brightness_neon(pixels, adjustment); }
        }
    }
    
    // 通用SIMD實作或標量實作為後備
    apply_brightness_simd(pixels, adjustment);
}

import rust_media_engine

# 初始化最佳化引擎
engine = rust_media_engine.VideoEngine()

# 建立記憶體池
frame_pool = engine.create_frame_pool(width=1920, height=1080, format="yuv420p")

def process_webrtc_frame(raw_frame):
    # 從Rust記憶體池分配影片幀
    frame = frame_pool.get_frame()
    
    # 複製WebRTC幀資料到最佳化的記憶體區域
    frame.copy_from(raw_frame)
    
    # 使用SIMD加速處理
    engine.apply_brightness(frame, 10)
    engine.apply_contrast(frame, 1.2)
    
    # AI模型處理
    ml_model.process(frame.as_numpy_array())
    
    return frame

use pyo3::prelude::*;
use std::simd::u8x16;

#[pyfunction]
fn apply_brightness_python(pixels: Vec<u8>, adjustment: u8) -> Vec<u8> {
    let mut pixels = pixels;
    apply_brightness_simd(&mut pixels, adjustment);
    pixels
}

#[pymodule]
fn rust_video_processing(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(apply_brightness_python, m)?)?;
    Ok(())
}

import rust_video_processing
import numpy as np
import cv2

frame = cv2.imread("frame.jpg")
gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
brightened = rust_video_processing.apply_brightness_python(gray_frame.flatten().tolist(), 30)

#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <linux/types.h>
#include <bpf/bpf_helpers.h>

SEC("xdp")
int filter_webrtc_packets(struct __sk_buff *skb) {
    void *data = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end) return XDP_DROP;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end) return XDP_DROP;

    if (ip->protocol == IPPROTO_UDP) {
        struct udphdr *udp = (void *)(ip + 1);
        if ((void *)(udp + 1) > data_end) return XDP_DROP;

        if (udp->dest == htons(3478) || udp->dest == htons(5349)) {
            return XDP_DROP; // 丟棄無效的STUN/TURN封包
        }
    }
    return XDP_PASS;
}

use redbpf::{load::Loader, xdp::attach_xdp, xdp::XdpFlags};
use std::fs::File;

fn load_ebpf() -> std::io::Result<()> {
    let mut file = File::open("filter_webrtc_packets.o")?;
    let loader = Loader::load(&mut file)?;

    for prog in loader.xdps() {
        attach_xdp(&prog, "eth0", XdpFlags::default()).expect("Failed to attach XDP");
    }

    Ok(())
}

fn main() {
    load_ebpf().expect("Failed to load eBPF filter");
}

SEC("classifier")
int prioritize_vip_users(struct __sk_buff *skb) {
    void *data = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;

    struct iphdr *ip = data + sizeof(struct ethhdr);
    if ((void *)(ip + 1) > data_end) return TC_ACT_OK;

    struct udphdr *udp = (void *)(ip + 1);
    if ((void *)(udp + 1) > data_end) return TC_ACT_OK;

    char vip_tag[] = "VIP-STREAM";
    if (__builtin_memcmp(data + sizeof(struct ethhdr) + sizeof(struct iphdr) + sizeof(struct udphdr), vip_tag, sizeof(vip_tag) - 1) == 0) {
        return TC_ACT_SHOT; // 為VIP使用者提升優先順序
    }

    return TC_ACT_OK;
}

use bpf::maps::PerfEventArray;
use pyo3::prelude::*;

#[pyfunction]
fn get_packet_stats() -> Vec<(u32, u32)> {
    let mut stats = Vec::new();
    let mut events = PerfEventArray::new("packet_stats").unwrap();

    for event in events.read() {
        stats.push((event.src_ip, event.packet_count));
    }

    stats
}

#[pymodule]
fn rust_ebpf_monitor(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(get_packet_stats, m)?)?;
    Ok(())
}

import rust_ebpf_monitor
import numpy as np
from sklearn.linear_model import LinearRegression

stats = rust_ebpf_monitor.get_packet_stats()
X = np.array([s[0] for s in stats]).reshape(-1, 1)
y = np.array([s[1] for s in stats])

model = LinearRegression()
model.fit(X, y)
predicted_traffic = model.predict(X[-1].reshape(1, -1))

if predicted_traffic > 10000:
    print("High traffic detected, adjusting bandwidth allocation.")

#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>

struct ice_sdp_cache {
    __u32 src_ip;
    __u32 dst_ip;
    char sdp_data[256];
};

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 1024);
    __type(key, __u32);
    __type(value, struct ice_sdp_cache);
} ice_sdp_cache_map SEC(".maps");

SEC("xdp")
int cache_ice_sdp_packets(struct __sk_buff *skb) {
    void *data = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end) return XDP_PASS;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end) return XDP_PASS;

    struct udphdr *udp = (void *)(ip + 1);
    if ((void *)(udp + 1) > data_end) return XDP_PASS;

    if (udp->dest == htons(3478) || udp->dest == htons(5349)) {
        struct ice_sdp_cache cache_entry = {
            .src_ip = ip->saddr,
            .dst_ip = ip->daddr
        };
        __builtin_memcpy(cache_entry.sdp_data, data + sizeof(struct ethhdr) + sizeof(struct iphdr) + sizeof(struct udphdr), 256);

        bpf_map_update_elem(&ice_sdp_cache_map, &ip->saddr, &cache_entry, BPF_ANY);
    }

    return XDP_PASS;
}

use redbpf::{load::Loader, xdp::attach_xdp, xdp::XdpFlags};
use std::fs::File;

fn load_ebpf_cache() -> std::io::Result<()> {
    let mut file = File::open("cache_ice_sdp_packets.o")?;
    let loader = Loader::load(&mut file)?;

    for prog in loader.xdps() {
        attach_xdp(&prog, "eth0", XdpFlags::default()).expect("Failed to attach XDP");
    }

    Ok(())
}

fn main() {
    load_ebpf_cache().expect("Failed to load eBPF caching program");
}

SEC("sockops")
int adjust_quic_congestion_control(struct __sk_buff *skb) {
    struct bpf_sock_ops *skops = (struct bpf_sock_ops *) skb;
    
    if (skops->op == BPF_SOCK_OPS_TCP_CONGESTION) {
        bpf_setsockopt(skops, SOL_TCP, TCP_CONGESTION, "bbr", 3);
    }

    return 1;
}

use bpf::maps::PerfEventArray;
use pyo3::prelude::*;

#[pyfunction]
fn get_network_stats() -> Vec<(u32, u32)> {
    let mut stats = Vec::new();
    let mut events = PerfEventArray::new("network_stats").unwrap();

    for event in events.read() {
        stats.push((event.src_ip, event.packet_count));
    }

    stats
}

#[pymodule]
fn rust_quic_monitor(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(get_network_stats, m)?)?;
    Ok(())
}

import rust_quic_monitor
import numpy as np
from sklearn.linear_model import LinearRegression

stats = rust_quic_monitor.get_network_stats()
X = np.array([s[0] for s in stats]).reshape(-1, 1)
y = np.array([s[1] for s in stats])

model = LinearRegression()
model.fit(X, y)
predicted_traffic = model.predict(X[-1].reshape(1, -1))

if predicted_traffic > 5000:
    print("預測到網路壅塞，正在調整QUIC引數。")

use tokio::time::{sleep, Duration};
use reqwest::Client;

async fn monitor_bandwidth(client: &Client) -> Result<f32, reqwest::Error> {
    let start = std::time::Instant::now();
    let response = client.get("https://example.com/testfile")
        .send()
        .await?;
    let elapsed = start.elapsed().as_secs_f32();
    
    let content_length = response.content_length().unwrap_or(0) as f32;
    Ok(content_length / elapsed)
}

#[tokio::main]
async fn main() {
    let client = Client::new();
    
    loop {
        match monitor_bandwidth(&client).await {
            Ok(bandwidth) => println!("目前頻寬: {:.2} Mbps", bandwidth),
            Err(e) => println!("頻寬監測錯誤: {:?}", e),
        }
        sleep(Duration::from_secs(5)).await;
    }
}

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# 載入歷史頻寬測量資料
data = np.load("bandwidth_data.npy")

# 準備訓練資料
X = data[:-1].reshape(-1, 10, 1)  # 使用前10次測量作為輸入
y = data[1:].reshape(-1, 1)       # 預測下一個頻寬值

# 定義LSTM模型
model = Sequential([
    LSTM(64, return_sequences=True, input_shape=(10, 1)),
    LSTM(32),
    Dense(1, activation='linear')
])

model.compile(optimizer='adam', loss='mse')
model.fit(X, y, epochs=50, batch_size=16)

model.save("bandwidth_predictor.h5")