O estado atual é representado por uma tupla (começo, beta), onde: começo é o estoque disponível atual (itens em estoque), beta é o estoque atual sob pedido (itens pedidos, mas ainda não recebidos), init_inv calcula o inventário inicial totalidade somando começo e beta.
Logo, precisamos simular a demanda do cliente usando a distribuição de Poisson com valor lambda “self.poisson_lambda”. Cá, a demanda mostra a aleatoriedade da demanda do cliente:
alpha, beta = state
init_inv = alpha + beta
demand = np.random.poisson(self.poisson_lambda)Sua visita nos ajuda a continuar oferecendo o melhor para você! hv pv pf pg ph pw pj pk pl px pn po pp py pr ps pt gn bk">Reparo: A distribuição de Poisson é usada para modelar a demanda, que é uma escolha generalidade para modelar eventos aleatórios, porquê chegadas de clientes. No entanto, podemos treinar o protótipo com dados históricos de demanda ou interagir ao vivo com o envolvente em tempo real. Em sua origem, o tirocínio por reforço trata do tirocínio com os dados e não requer conhecimento prévio de um protótipo.
Agora, o “próximo começo” que é o estoque disponível pode ser escrito porquê max(0,init_inv-demand). O que isso significa é que se a demanda for maior que o estoque inicial, logo o novo começo será zero, caso contrário, init_inv-demand.
O dispêndio vem em duas partes. Dispêndio de retenção: é calculado multiplicando o número de bicicletas na loja pelo dispêndio de manutenção por unidade. Logo, temos outro dispêndio, que é dispêndio de falta de estoque. É um dispêndio que precisamos remunerar pelos casos de falta de demanda. Essas duas partes formam a “recompensa” que tentamos maximizar usando o método de aprendizagem por reforço (a melhor maneira de colocar é que queremos minimizar o dispêndio, para maximizar a recompensa).
Sua visita nos ajuda a continuar oferecendo o melhor para você! nn no np nq re rf rg bp rh bb bk">new_alpha = max(0, init_inv - demand)
holding_cost = -new_alpha * self.holding_cost
stockout_cost = 0if demand > init_inv:
stockout_cost = -(demand - init_inv) * self.stockout_cost
reward = holding_cost + stockout_cost
next_state = (new_alpha, action)
Exploração – Exploração em Q-Learning
A escolha da ação no método Q-learning envolve qualquer proporção de exploração para obter uma visão universal do valor Q para todos os estados na tábua Q. Para fazer isso, em cada ação escolhida, há uma chance épsilon de adotarmos uma abordagem de exploração e selecionarmos uma ação “aleatoriamente”, enquanto, com uma chance de 1-ϵ, tomarmos a melhor ação provável da tábua Q.
def choose_action(self, state):# Epsilon-greedy action selection
if np.random.rand() < self.epsilon:
return np.random.choice(self.user_capacity Sua visita nos ajuda a continuar oferecendo o melhor para você! (state[0] + state[1]) + 1)
else:
return max(self.Q[state], key=self.Q[state].get)
Agente de Treinamento RL
O treinamento do agente RL é feito pela função “train”, e segue porquê: Primeiro, precisamos inicializar o Q (estrutura de léxico vazia). Em seguida, as experiências são coletadas em cada lote (self.batch.append((estado, ação, recompensa, next_state))) e a tábua Q é atualizada ao final de cada lote (self.update_Q(self.batch)). O número de episódios é restringido a “max_actions_per_episode” em cada lote. O número de episódios é o número de vezes que o agente interage com o envolvente para aprender a política ideal.
Cada incidente começa com um estado atribuído aleatoriamente e, embora o número de ações seja subordinado a max_actions_per_episode, a coleta de dados para esse lote continua.
def train(self):self.Q = self.initialize_Q() # Reinitialize Q-table for each training run
for episode in range(self.episodes):
alpha_0 = random.randint(0, self.user_capacity)
beta_0 = random.randint(0, self.user_capacity - alpha_0)
state = (alpha_0, beta_0)
#total_reward = 0
self.batch = [] # Reset the batch at the start of each episode
action_taken = 0
while action_taken < self.max_actions_per_episode:
action = self.choose_action(state)
next_state, reward = self.simulate_transition_and_reward(state, action)
self.batch.append((state, action, reward, next_state)) # Collect experience
state = next_state
action_taken += 1
self.update_Q(self.batch) # Update Q-table using the batch
Tags:
Crédito: Manadeira Original
