智能限速算法：基于强化学习的动态请求间隔控制

#亿牛云爬虫代理 
PROXY = {
    "http": "http://username:password@t.16yun.cn:31111",
    "https": "http://username:password@t.16yun.cn:31111",
}

import time, random
import requests
import numpy as np
from collections import deque
import torch
import torch.nn as nn
import torch.optim as optim

# 强化学习网络定义
class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, action_dim),
        )

    def forward(self, x):
        return self.net(x)

# 配置代理与请求头 参考亿牛云爬虫代理 www.16yun.cn
PROXY = {
    "http": "http://your_username:your_password@t.16yun.cn:31111",
    "https": "http://your_username:your_password@t.16yun.cn:31111",
}
HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
                  "(KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36",
    "Cookie": "sessionid=YOUR_SESSION_ID; ..."  # 如有必要，可加上登录后获得的 cookies
}

# 强化学习参数
ACTIONS = [0.5, 1, 2, 5]  # 可选的请求间隔（秒）:contentReference[oaicite:9]{index=9}
state_dim = 10           # 示例：使用最近 10 条记录
action_dim = len(ACTIONS)
memory = deque(maxlen=10000)
batch_size = 64
gamma = 0.99
epsilon = 1.0
epsilon_decay = 0.995
min_epsilon = 0.1
lr = 1e-3

# 创建 DQN
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
policy_net = DQN(state_dim, action_dim).to(device)
target_net = DQN(state_dim, action_dim).to(device)
target_net.load_state_dict(policy_net.state_dict())
optimizer = optim.Adam(policy_net.parameters(), lr=lr)
loss_fn = nn.MSELoss()

# 环境状态初始化
state = np.zeros(state_dim)

def select_action(state):
    global epsilon
    if random.random() < epsilon:
        return random.randrange(action_dim)
    with torch.no_grad():
        q_values = policy_net(torch.FloatTensor(state).to(device))
        return int(torch.argmax(q_values).item())

def optimize():
    if len(memory) < batch_size:
        return
    batch = random.sample(memory, batch_size)
    states, actions, rewards, next_states = map(np.array, zip(*batch))
    states = torch.FloatTensor(states).to(device)
    next_states = torch.FloatTensor(next_states).to(device)
    actions = torch.LongTensor(actions).view(-1,1).to(device)
    rewards = torch.FloatTensor(rewards).to(device)

    q_values = policy_net(states).gather(1, actions).squeeze()
    next_q = target_net(next_states).max(1)[0].detach()
    expected_q = rewards + gamma * next_q
    loss = loss_fn(q_values, expected_q)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# 主循环
for episode in range(1000):
    successes = 0
    for step in range(200):
        action_idx = select_action(state)
        interval = ACTIONS[action_idx]
        time.sleep(interval)  # 智能等待
        try:
            resp = requests.get("https://www.douyin.com/discover", 
                                headers=HEADERS, proxies=PROXY, timeout=10)
            if resp.status_code == 200:
                reward = 1.0
                successes += 1
            else:
                reward = -1.0
        except requests.exceptions.RequestException:
            reward = -1.0

        # 更新状态（简单示例：移位并加入新结果）
        next_state = np.roll(state, -1)
        next_state[-1] = 1 if reward>0 else 0
        memory.append((state, action_idx, reward, next_state))
        state = next_state

        optimize()

    # 更新 ε 和目标网络
    epsilon = max(min_epsilon, epsilon * epsilon_decay)
    if episode % 10 == 0:
        target_net.load_state_dict(policy_net.state_dict())
    print(f"Episode {episode}, Successes: {successes}, Epsilon: {epsilon:.3f}")