【深度学习】python实现等距随机抽样

        在实际的样本抽帧需求中,往往有这样一种需求,例如,从20帧到75帧,抽取29帧数据,如果使用python自带的randint 函数,往往抽取的数据间隔是不一致的,这就需要等距随机抽样。

        等距随机抽样就是,从开始的索引到结束索引,随机抽取若干个数,并要求数字之间的间隔尽可能的一致。搜索了好久,有使用randint的,使用randsample的,等等,都不满足我的需求,这样,只能是自己写了,所以将代码贴出来,如有帮助,希望大家留个脚印。

        使用方法,例如从[20,75],随机抽取29个数,调用方式如下:

如果Status为False证明你给的数组的个数小于你抽取的个数。

piIndex,status = GetSameDistRandomFrame(20,75,29)
def GetSameDistRandomFrame(iStartFrame,iEndFrame,iGetNum):
    status = True
    FrameIndex = []
    iLength =  iEndFrame -iStartFrame +1 
    iMargin =iLength//iGetNum
    if iMargin == 0:
         status = False
         return FrameIndex,status
    iLeft = iLength%iGetNum
    iAddIndex = random.sample(range(0,iGetNum-1),iLeft)
    iAddIndex.sort()
    iEveryMargin = np.ones(iGetNum,dtype=np.int64) * iMargin
    for i in range(iLeft):
        index = iAddIndex[i]
        iEveryMargin[index] = iEveryMargin[index] + 1
    iStartIndex = iStartFrame
    for i in range(iGetNum):
        iEndIndex = iStartIndex + iEveryMargin[i] - 1
        FrameIndex.append(iEndIndex)
        iGet = random.randint(iStartIndex,iEndIndex)
        iStartIndex = iEndIndex +1
    return FrameIndex,status

系统说我篇幅过段,后面都是废话,请忽略,谢谢!!!

或受成本拖累,康师傅方便面、饮品两大核心业务净利润降近四成。

8月22日晚间,康师傅控股有限公司(00322.HK,康师傅控股)披露2022年中期业绩。今年上半年,康师傅收益约382.17亿元,同比(较上年同期)增长7.97%;公司股东应占溢利同比下滑38.42%至12.53亿元,基本每股溢利为22.25分。

康师傅并未扭转2021年的净利润下滑态势,今年上半年,净利润同比大幅下滑超38%。实际上,康师傅自2021年中期以来一直处于“增收不增利”的状态。康师傅在财报中指出,净利润受毛利率下降2.83个百分点影响下滑,中期毛利率也降至近十年低点。

康师傅近五年中期及全年营收、净利润表现 来源:Wind康师傅的核心业务分为方便面及饮品两大板块,而这两大板块在今年上半年均出现毛利率下滑拖累净利润的情况。今年上半年,康师傅的方便面业务营收135.48亿元,同比增长6.49%,占集团总收益的35.45%。据尼尔森资料,康师傅方便面的销量与销售额继续保持市场占有率首位,分别为44.6%与46.7%。

而康师傅在财报中坦言,期内由于原材料价格上涨,方便面的毛利率同比下滑3.26%至20.63%,进而导致方便面板块上半年的净利润同比下滑39.23%至5.44亿元。

尽管今年上半年康师傅饮品业务整体收益242.98亿元,同比增长9.08%,但饮品板块同样面临原材料价格上涨压力及组合变化,毛利率同比下降2.64%至32.14%,导致饮品板块上半年净利润同比下降37.06%至7.44亿元。

 

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深度强化学习是一种将深度学习和强化学习相结合的技术,可以用于解决许多复杂的控制问题。在这里,我将给出一个使用PyTorch实现深度强化学习的简单示例代码。代码将使用DQN算法来解决经典的CartPole问题。 首先,我们需要导入所需的库: ```python import random import numpy as np import gym import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F from collections import deque ``` 接下来,我们需要定义智能体的神经网络模型。在这个例子中,我们将使用一个简单的全连接网络,它将接收状态作为输入,并输出每个可能的动作的Q值。在这里,我们定义了一个名为DQN的类,它继承自PyTorch的nn.Module类: ```python class DQN(nn.Module): def __init__(self, state_dim, action_dim): super(DQN, 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 ``` 然后,我们需要定义一个经验回放缓冲区,它将存储智能体的经验,以便我们可以从中随机抽样来训练神经网络。在这里,我们使用Python的deque库来实现缓冲区: ```python class ReplayBuffer(): def __init__(self, capacity): self.buffer = deque(maxlen=capacity) def push(self, state, action, reward, next_state, done): self.buffer.append((state, action, reward, next_state, done)) def sample(self, batch_size): state, action, reward, next_state, done = zip(*random.sample(self.buffer, batch_size)) return np.array(state), np.array(action), np.array(reward), np.array(next_state), np.array(done) def __len__(self): return len(self.buffer) ``` 接下来,我们需要定义一个函数来执行智能体的动作,这个函数将负责根据当前状态选择一个动作。在这里,我们将使用epsilon-greedy策略,该策略以epsilon的概率随机选择一个动作,以1-epsilon的概率选择当前Q值最大的动作: ```python def select_action(state, epsilon): if random.random() < epsilon: return env.action_space.sample() else: state = torch.FloatTensor(state).unsqueeze(0).to(device) q_value = policy_net(state) return q_value.max(1)[1].item() ``` 然后,我们需要定义训练函数。在这个函数中,我们将执行一系列动作,并将经验存储在经验回放缓冲区中。然后,我们将从缓冲区中抽样一批经验,并使用它来训练神经网络。在这里,我们将使用Huber损失函数来计算Q值的误差: ```python def train(batch_size, gamma): if len(buffer) < batch_size: return state, action, reward, next_state, done = buffer.sample(batch_size) state = torch.FloatTensor(state).to(device) next_state = torch.FloatTensor(next_state).to(device) action = torch.LongTensor(action).to(device) reward = torch.FloatTensor(reward).to(device) done = torch.FloatTensor(done).to(device) q_value = policy_net(state).gather(1, action.unsqueeze(1)).squeeze(1) next_q_value = target_net(next_state).max(1)[0] expected_q_value = reward + gamma * next_q_value * (1 - done) loss = F.smooth_l1_loss(q_value, expected_q_value.detach()) optimizer.zero_grad() loss.backward() optimizer.step() ``` 最后,我们可以开始训练我们的智能体。在这个例子中,我们将使用CartPole-v0环境,并将训练1000个回合。每个回合将持续最多200个时间步长,并且我们将使用Adam优化器来训练我们的神经网络。在每个回合结束时,我们将更新目标网络,并将epsilon逐渐减小,以使智能体在训练过程中变得更加自信: ```python env = gym.make('CartPole-v0') state_dim = env.observation_space.shape[0] action_dim = env.action_space.n 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=1e-3) buffer = ReplayBuffer(10000) batch_size = 128 gamma = 0.99 epsilon_start = 1.0 epsilon_final = 0.01 epsilon_decay = 500 for i_episode in range(1000): state = env.reset() epsilon = epsilon_final + (epsilon_start - epsilon_final) * np.exp(-i_episode / epsilon_decay) for t in range(200): action = select_action(state, epsilon) next_state, reward, done, _ = env.step(action) buffer.push(state, action, reward, next_state, done) state = next_state train(batch_size, gamma) if done: break if i_episode % 20 == 0: target_net.load_state_dict(policy_net.state_dict()) print("Episode: {}, score: {}".format(i_episode, t)) ``` 这就是使用PyTorch实现深度强化学习的基本代码。当然,这只是一个简单的例子,实际上,深度强化学习的应用非常广泛,并且还有很多优化技术可以用来提高性能。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值