使用Redis生成全局唯一id

为了生成一个符合要求的分布式全局ID,我们可以使用 StringRedisTemplate 来实现。这个ID由三部分组成:

  1. 符号位(1 bit):始终为0,表示正数。
  2. 时间戳(31 bit):表示从某个起始时间点(例如2023-01-01 00:00:00)到现在的秒数。
  3. 序列号(32 bit):用于在同一秒内生成不同的ID。

实现步骤

  1. 计算时间戳:从某个起始时间点到现在的秒数。
  2. 生成序列号:使用Redis的原子递增操作来生成序列号。
  3. 组合ID:将时间戳和序列号组合成一个64位的长整型数字。

代码实现

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.concurrent.TimeUnit;

@Service
public class DistributedIdGenerator {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // 起始时间点,例如2023-01-01 00:00:00
    private static final long EPOCH = ZonedDateTime.of(2023, 1, 1, 0, 0, 0, 0, ZoneId.systemDefault()).toInstant().toEpochMilli() / 1000;

    // 序列号的Redis键前缀
    private static final String SEQUENCE_KEY_PREFIX = "sequence:";

    /**
     * 生成分布式全局ID
     *
     * @return 分布式全局ID
     */
    public long generateId() {
        // 获取当前时间戳(从起始时间点到现在的秒数)
        long currentTimeSec = Instant.now().getEpochSecond() - EPOCH;

        // 生成序列号
        String sequenceKey = SEQUENCE_KEY_PREFIX + currentTimeSec;
        long sequence = stringRedisTemplate.opsForValue().increment(sequenceKey, 1);
        if (sequence >= (1L << 32)) { // 序列号溢出,重置为0
            stringRedisTemplate.expire(sequenceKey, 1, TimeUnit.SECONDS); // 设置1秒后过期
            sequence = 0;
        }

        // 组合ID
        long id = (currentTimeSec << 32) | sequence;

        return id;
    }
}

代码解释

  1. EPOCH:起始时间点,例如2023-01-01 00:00:00,转换为秒数。
  2. SEQUENCE_KEY_PREFIX:Redis中存储序列号的键前缀。
  3. generateId 方法
    • currentTimeSec:从起始时间点到现在的秒数。
    • sequenceKey:根据当前时间戳生成的Redis键。
    • sequence:使用 opsForValue().increment 方法生成序列号,确保在同一秒内生成不同的ID。
    • 序列号溢出处理:如果序列号达到最大值(2^32 - 1),则重置为0,并设置键在1秒后过期。
    • 组合ID:将时间戳左移32位,然后与序列号进行按位或操作,生成最终的64位ID。

测试代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class IdController {

    @Autowired
    private DistributedIdGenerator idGenerator;

    @GetMapping("/generate-id")
    public long generateId() {
        return idGenerator.generateId();
    }
}

DQN(Deep Q-Network)是一种使用深度神经网络实现的强化学习算法,用于解决离散动作空间的问题。在PyTorch中实现DQN可以分为以下几个步骤: 1. 定义神经网络:使用PyTorch定义一个包含多个全连接层的神经网络,输入为状态空间的维度,输出为动作空间的维度。 ```python import torch.nn as nn import torch.nn.functional as F class QNet(nn.Module): def __init__(self, state_dim, action_dim): super(QNet, self).__init__() self.fc1 = nn.Linear(state_dim, 64) self.fc2 = nn.Linear(64, 64) self.fc3 = nn.Linear(64, action_dim) def forward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x ``` 2. 定义经验回放缓存:包含多条经验,每条经验包含一个状态、一个动作、一个奖励和下一个状态。 ```python import random class ReplayBuffer(object): def __init__(self, max_size): self.buffer = [] self.max_size = max_size def push(self, state, action, reward, next_state): if len(self.buffer) < self.max_size: self.buffer.append((state, action, reward, next_state)) else: self.buffer.pop(0) self.buffer.append((state, action, reward, next_state)) def sample(self, batch_size): state, action, reward, next_state = zip(*random.sample(self.buffer, batch_size)) return torch.stack(state), torch.tensor(action), torch.tensor(reward), torch.stack(next_state) ``` 3. 定义DQN算法:使用PyTorch定义DQN算法,包含训练和预测两个方法。 ```python class DQN(object): def __init__(self, state_dim, action_dim, gamma, epsilon, lr): self.qnet = QNet(state_dim, action_dim) self.target_qnet = QNet(state_dim, action_dim) self.gamma = gamma self.epsilon = epsilon self.lr = lr self.optimizer = torch.optim.Adam(self.qnet.parameters(), lr=self.lr) self.buffer = ReplayBuffer(100000) self.loss_fn = nn.MSELoss() def act(self, state): if random.random() < self.epsilon: return random.randint(0, action_dim - 1) else: with torch.no_grad(): q_values = self.qnet(state) return q_values.argmax().item() def train(self, batch_size): state, action, reward, next_state = self.buffer.sample(batch_size) q_values = self.qnet(state).gather(1, action.unsqueeze(1)).squeeze(1) target_q_values = self.target_qnet(next_state).max(1)[0].detach() expected_q_values = reward + self.gamma * target_q_values loss = self.loss_fn(q_values, expected_q_values) self.optimizer.zero_grad() loss.backward() self.optimizer.step() def update_target_qnet(self): self.target_qnet.load_state_dict(self.qnet.state_dict()) ``` 4. 训练模型:使用DQN算法进行训练,并更新目标Q网络。 ```python dqn = DQN(state_dim, action_dim, gamma=0.99, epsilon=1.0, lr=0.001) for episode in range(num_episodes): state = env.reset() total_reward = 0 for step in range(max_steps): action = dqn.act(torch.tensor(state, dtype=torch.float32)) next_state, reward, done, _ = env.step(action) dqn.buffer.push(torch.tensor(state, dtype=torch.float32), action, reward, torch.tensor(next_state, dtype=torch.float32)) state = next_state total_reward += reward if len(dqn.buffer.buffer) > batch_size: dqn.train(batch_size) if step % target_update == 0: dqn.update_target_qnet() if done: break dqn.epsilon = max(0.01, dqn.epsilon * 0.995) ``` 5. 测试模型:使用训练好的模型进行测试。 ```python total_reward = 0 state = env.reset() while True: action = dqn.act(torch.tensor(state, dtype=torch.float32)) next_state, reward, done, _ = env.step(action) state = next_state total_reward += reward if done: break print("Total reward: {}".format(total_reward)) ``` 以上就是在PyTorch中实现DQN强化学习的基本步骤。需要注意的是,DQN算法中还有很多细节和超参数需要调整,具体实现过程需要根据具体问题进行调整。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值