Stars League stats & predictions Tomorrow

Injury updates can significantly impact match outcomes. Here’s the latest squad news ahead of tomorrow’s fixtures:

• Dodgy Injuries: Key Absences
• Erbil SC: Midfielder Omar Abdulrahman is doubtful due to muscle strain but may still feature after intensive physiotherapy sessions today.
• Najaf FC: Forward Kareem Allami remains sidelined with an ankle injury sustained last week; his return is uncertain without risking further aggravation.ZhuoZhuoWang/RL-DQN-Pong<|file_sep|>/q_learning_agent.py import numpy as np import tensorflow as tf from collections import deque import random class QLearningAgent: def __init__(self): self.learning_rate = 0.1 self.discount_factor = 0.99 self.exploration_rate = 1 self.exploration_decay = 0.995 self.exploration_min = 0.01 self.state_size = (80 * 80,) self.action_size = 3 self.memory = deque(maxlen=2000) self.gamma = self.discount_factor self.epsilon = self.exploration_rate self.epsilon_min = self.exploration_min self.epsilon_decay = self.exploration_decay # create q network model self.model = self.create_model() def create_model(self): # Neural Net for Deep-Q learning Model model = tf.keras.models.Sequential() model.add(tf.keras.layers.Dense(64,input_dim=self.state_size[0],activation='relu')) model.add(tf.keras.layers.Dense(64,input_dim=self.state_size[0],activation='relu')) model.add(tf.keras.layers.Dense(self.action_size)) model.compile(loss='mse',optimizer=tf.keras.optimizers.Adam(lr=self.learning_rate)) return model def remember(self,state ,action ,reward ,next_state ,done): # store state transition in memory # state ,action ,reward ,next_state ,done self.memory.append((state ,action ,reward ,next_state ,done)) def act(self,state): if np.random.rand() <= self.epsilon: return random.randrange(self.action_size) act_values = self.model.predict(state) return np.argmax(act_values[0]) def replay(self,batch_size): minibatch = random.sample(self.memory,batch_size) states = np.zeros((batch_size,self.state_size[0])) next_states = np.zeros((batch_size,self.state_size[0])) actions , rewards , dones = [], [], [] for i in range(batch_size): state , action , reward , next_state , done = minibatch[i] states[i] = state next_states[i] = next_state actions.append(action) rewards.append(reward) dones.append(done) target = rewards + (1 - dones) * (self.gamma * np.amax(self.model.predict_on_batch(next_states),axis=1)) target_full = self.model.predict_on_batch(states) indxs = np.array([i for i in range(batch_size)]) target_full[[indxs], [actions]] = target # train network using target value y_t+1 _ = self.model.fit(states,target_full,batch_size=batch_size) if self.epsilon > self.epsilon_min: self.epsilon *= self.epsilon_decay def load(self,name): return tf.keras.models.load_model(name) def save(self,name): return tf.keras.models.save_model(self.model,name)<|repo_name|>ZhuoZhuoWang/RL-DQN-Pong<|file_sep|>/pong.py import gym env_name='Pong-v0' env=gym.make(env_name) print(env.observation_space.shape) # (210L x 160L x 3) matrix representing RGB values at each pixel print(env.action_space.n) # Number of actions available print(env.reset().shape) # Reset environment back to initial state # env.render() # Render environment # env.step(1) # Take action # env.close() <|repo_name|>ZhuoZhuoWang/RL-DQN-Pong<|file_sep|>/train.py import gym import numpy as np from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.optimizers import Adam import matplotlib.pyplot as plt from q_learning_agent import QLearningAgent env_name='Pong-v0' env=gym.make(env_name) agent=QLearningAgent() def prepro(img): img= img[35:195] # Crop image down img=img[::2,:::2,:] # Downsample by factor of 2 img=img.mean(axis=2) # Convert from RGB image -> Grayscale img[img==144]=0 # erase background type 1 img[img==109]=0 # erase background type 2 img[img!=0]=1 # everything else (paddles,score,ball) just set them all equal return img.astype(np.float).ravel() def postpro(img): img=img.reshape(80,80) plt.imshow(img,cmap='gray') plt.show() episodes=50000 batch_size=32 scores=[] for e in range(episodes): state=prepro(env.reset()) state=np.reshape(state,[1,state.shape[0]]) done=False score=0 while not done: action=agent.act(state) next_state,reward,_=env.step(action) next_state=prepro(next_state) next_state=np.reshape(next_state,[1,next_state.shape[0]]) done=False if reward==0 else True score+=reward <|repo_name|>ZhuoZhuoWang/RL-DQN-Pong<|file_sep|>/README.md # RL-DQN-Pong This project implements Deep Q-Network(DQN) algorithm using Tensorflow/Keras. DQN was first introduced by Mnih et al., DeepMind's team (2015), which proposed using deep neural networks instead of Q-tables. The key idea behind DQN is that instead of storing Q-values in tables we store them in neural networks.  In order to learn Q-values more efficiently we need two separate neural networks: Q-network: this is our main neural network which predicts Q-values given states. Target network: it has identical structure as Q-network but its parameters are frozen (i.e., not updated). It takes states as inputs just like Q-network but outputs different Q-values. We update our main Q-network every step but we update our target network less frequently. Here is an example showing how we use both networks: Let's say we take an action "up" from state "s" then we get reward "r" after which we reach state "s'". Our goal is find optimal policy so we need find optimal action "a" from state "s'". We use Bellman equation:  The above equation shows that our predicted Q-value (Q(s,a)) should be equal sum of reward (r) received after taking action "a" from state "s" plus discounted maximum predicted Q-value (γmaxQ(s',a')) obtained from state s'. Notice that we use max function because we want our agent choose best possible action which leads him/her towards optimal policy. We use Target network instead of Q-network because it gives more stable targets since its parameters do not change every step. In addition we use replay buffer which stores last n transitions e.g., (s,a,r,s'). This way we can sample mini-batches from replay buffer instead of sampling single transitions one-by-one sequentially during training process. ## Install dependencies: bash pip install -r requirements.txt ## Run training script: bash python train.py --episodes=(default:100000) --save_every=(default:10000) <|file_sep|># RL-DQN-Pong This project implements Deep Q-Network(DQN) algorithm using Tensorflow/Keras. DQN was first introduced by Mnih et al., DeepMind's team (2015), which proposed using deep neural networks instead of Q-tables. The key idea behind DQN is that instead of storing Q-values in tables we store them in neural networks. In order to learn Q-values more efficiently we need two separate neural networks: Q-network: this is our main neural network which predicts Q-values given states. Target network: it has identical structure as Q-network but its parameters are frozen (i.e., not updated). It takes states as inputs just like Q-network but outputs different Q-values. We update our main Q-network every step but we update our target network less frequently. Here is an example showing how we use both networks: Let's say we take an action "up" from state "s" then we get reward "r" after which we reach state "s'". Our goal is find optimal policy so we need find optimal action "a" from state "s'". We use Bellman equation:  The above equation shows that our predicted Q-value (Q(s,a)) should be equal sum of reward (r) received after taking action "a" from