\",\n \"the move function and other stuff # on touch_down() = When our fingers/mouse\",\n \"velocity_y) # Latest Position of the Ball = Current Velocity + Current Position\",\n \"the screen class PongGame(Widget): ball = ObjectProperty(None) player1 = ObjectProperty(None) player2 = ObjectProperty(None)\",\n \"score if self.ball.x < 0: self.ball.velocity_x *= -1 self.player1.score += 1 # Bounce\",\n \"self.width - 50: self.ball.velocity_x *= -1 self.player2.score += 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def on_touch_move(self,\",\n \"touch_down() = When our fingers/mouse touches he screen # on touch_up() - when\",\n \"# Step 2 - Create the Game # Step 3 - Build the\",\n \"import Widget from kivy.properties import NumericProperty, ReferenceListProperty, ObjectProperty from kivy.vector import Vector from\",\n \"- when we lift our finger off the screen after touching it #\",\n \"# Bounce off left and increase th score if self.ball.x < 0: self.ball.velocity_x\",\n \"App \\\"\\\"\\\" from kivy.app import App from kivy.uix.widget import Widget from kivy.properties import\",\n \"import Vector from kivy.clock import Clock from random import randint class PongPaddle(Widget): score\",\n \"def bounce_ball(self, ball): if self.collide_widget(ball): ball.velocity_x *= -1 print('hello world') class PongBall(Widget): velocity_x\",\n \"ball = ObjectProperty(None) player1 = ObjectProperty(None) player2 = ObjectProperty(None) def serve_ball(self): self.ball.velocity =\",\n \"> self.width * 3 / 4: self.player2.center_y = touch.y class PongApp(App): def build(self):\",\n \"Current Position def move(self): self.pos = Vector(*self.velocity) + self.pos # Update - moving\",\n \"= NumericProperty(0) def bounce_ball(self, ball): if self.collide_widget(ball): ball.velocity_x *= -1 print('hello world') class\",\n \"touch.x > self.width * 3 / 4: self.player2.center_y = touch.y class PongApp(App): def\",\n \"50): self.ball.velocity_y *= -1.1 # Bounce off left and increase th score if\",\n \"the score if self.ball.x > self.width - 50: self.ball.velocity_x *= -1 self.player2.score +=\",\n \"left and increase th score if self.ball.x < 0: self.ball.velocity_x *= -1 self.player1.score\",\n \"player1 = ObjectProperty(None) player2 = ObjectProperty(None) def serve_ball(self): self.ball.velocity = Vector(4, 0).rotate(randint(0, 360))\",\n \"# Bounce off right and increase the score if self.ball.x > self.width -\",\n \"> self.width - 50: self.ball.velocity_x *= -1 self.player2.score += 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def\",\n \"3 / 4: self.player2.center_y = touch.y class PongApp(App): def build(self): game = PongGame()\",\n \"self.player1.center_y = touch.y if touch.x > self.width * 3 / 4: self.player2.center_y =\",\n \"PongBall(Widget): velocity_x = NumericProperty(0) velocity_y = NumericProperty(0) velocity = ReferenceListProperty(velocity_x, velocity_y) # Latest\",\n \"self.ball.x > self.width - 50: self.ball.velocity_x *= -1 self.player2.score += 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball)\",\n \"self.collide_widget(ball): ball.velocity_x *= -1 print('hello world') class PongBall(Widget): velocity_x = NumericProperty(0) velocity_y =\",\n \"Position of the Ball = Current Velocity + Current Position def move(self): self.pos\",\n \"top and bottom Y if (self.ball.y < 0) or (self.ball.y > self.height -\",\n \"*= -1.1 # Bounce off left and increase th score if self.ball.x <\",\n \"dt): self.ball.move() # Bounce off top and bottom Y if (self.ball.y < 0)\",\n \"= Vector(*self.velocity) + self.pos # Update - moving the ball by calling the\",\n \"self.width / 1 / 4: self.player1.center_y = touch.y if touch.x > self.width *\",\n \"Latest Position of the Ball = Current Velocity + Current Position def move(self):\",\n \"NumericProperty, ReferenceListProperty, ObjectProperty from kivy.vector import Vector from kivy.clock import Clock from random\",\n \"# Step 3 - Build the Game # Step 4 - Run the\",\n \"Vector(*self.velocity) + self.pos # Update - moving the ball by calling the move\",\n \"off left and increase th score if self.ball.x < 0: self.ball.velocity_x *= -1\",\n \"self.ball.velocity_y *= -1.1 # Bounce off left and increase th score if self.ball.x\",\n \"- moving the ball by calling the move function and other stuff #\",\n \"Game # Step 4 - Run the App \\\"\\\"\\\" from kivy.app import App\",\n \"random import randint class PongPaddle(Widget): score = NumericProperty(0) def bounce_ball(self, ball): if self.collide_widget(ball):\",\n \"*= -1 self.player2.score += 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def on_touch_move(self, touch): if touch.x <\",\n \"# on touch_down() = When our fingers/mouse touches he screen # on touch_up()\",\n \"/ 1 / 4: self.player1.center_y = touch.y if touch.x > self.width * 3\",\n \"= ReferenceListProperty(velocity_x, velocity_y) # Latest Position of the Ball = Current Velocity +\",\n \"touches he screen # on touch_up() - when we lift our finger off\",\n \"ReferenceListProperty, ObjectProperty from kivy.vector import Vector from kivy.clock import Clock from random import\",\n \"self.ball.velocity_x *= -1 self.player2.score += 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def on_touch_move(self, touch): if touch.x\",\n \"self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def on_touch_move(self, touch): if touch.x < self.width / 1 / 4:\",\n \"360)) def update(self, dt): self.ball.move() # Bounce off top and bottom Y if\",\n \"the App \\\"\\\"\\\" from kivy.app import App from kivy.uix.widget import Widget from kivy.properties\",\n \"Velocity + Current Position def move(self): self.pos = Vector(*self.velocity) + self.pos # Update\",\n \"When our fingers/mouse touches he screen # on touch_up() - when we lift\",\n \"self.player2.center_y = touch.y class PongApp(App): def build(self): game = PongGame() game.serve_ball() Clock.schedule_interval(game.update, 1.0\",\n \"the Game # Step 4 - Run the App \\\"\\\"\\\" from kivy.app import\",\n \"+= 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def on_touch_move(self, touch): if touch.x < self.width / 1\",\n \"class PongGame(Widget): ball = ObjectProperty(None) player1 = ObjectProperty(None) player2 = ObjectProperty(None) def serve_ball(self):\",\n \"if touch.x > self.width * 3 / 4: self.player2.center_y = touch.y class PongApp(App):\",\n \"= Current Velocity + Current Position def move(self): self.pos = Vector(*self.velocity) + self.pos\",\n \"touch.y if touch.x > self.width * 3 / 4: self.player2.center_y = touch.y class\",\n \"when we lift our finger off the screen after touching it # on_touch_move()\",\n \"on_touch_move() - when we drag our finger on the screen class PongGame(Widget): ball\",\n \"# Update - moving the ball by calling the move function and other\",\n \"other stuff # on touch_down() = When our fingers/mouse touches he screen #\",\n \"- Build the Game # Step 4 - Run the App \\\"\\\"\\\" from\",\n \"velocity = ReferenceListProperty(velocity_x, velocity_y) # Latest Position of the Ball = Current Velocity\",\n \"our finger on the screen class PongGame(Widget): ball = ObjectProperty(None) player1 = ObjectProperty(None)\",\n \"score = NumericProperty(0) def bounce_ball(self, ball): if self.collide_widget(ball): ball.velocity_x *= -1 print('hello world')\",\n \"off right and increase the score if self.ball.x > self.width - 50: self.ball.velocity_x\",\n \"self.player2.bounce_ball(self.ball) def on_touch_move(self, touch): if touch.x < self.width / 1 / 4: self.player1.center_y\",\n \"- Create the Game # Step 3 - Build the Game # Step\",\n \"= When our fingers/mouse touches he screen # on touch_up() - when we\",\n \"lift our finger off the screen after touching it # on_touch_move() - when\",\n \"on_touch_move(self, touch): if touch.x < self.width / 1 / 4: self.player1.center_y = touch.y\",\n \"-1 self.player1.score += 1 # Bounce off right and increase the score if\",\n \"Run the App \\\"\\\"\\\" from kivy.app import App from kivy.uix.widget import Widget from\",\n \"the ball by calling the move function and other stuff # on touch_down()\",\n \"if self.collide_widget(ball): ball.velocity_x *= -1 print('hello world') class PongBall(Widget): velocity_x = NumericProperty(0) velocity_y\",\n \"ball by calling the move function and other stuff # on touch_down() =\",\n \"on touch_up() - when we lift our finger off the screen after touching\",\n \"- 50: self.ball.velocity_x *= -1 self.player2.score += 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def on_touch_move(self, touch):\",\n \"after touching it # on_touch_move() - when we drag our finger on the\",\n \"def serve_ball(self): self.ball.velocity = Vector(4, 0).rotate(randint(0, 360)) def update(self, dt): self.ball.move() # Bounce\",\n \"if self.ball.x > self.width - 50: self.ball.velocity_x *= -1 self.player2.score += 1 self.player1.bounce_ball(self.ball)\",\n \"Create the Game # Step 3 - Build the Game # Step 4\",\n \"moving the ball by calling the move function and other stuff # on\",\n \"screen # on touch_up() - when we lift our finger off the screen\",\n \"< self.width / 1 / 4: self.player1.center_y = touch.y if touch.x > self.width\",\n \"Current Velocity + Current Position def move(self): self.pos = Vector(*self.velocity) + self.pos #\",\n \"NumericProperty(0) velocity = ReferenceListProperty(velocity_x, velocity_y) # Latest Position of the Ball = Current\",\n \"2 - Create the Game # Step 3 - Build the Game #\",\n \"finger on the screen class PongGame(Widget): ball = ObjectProperty(None) player1 = ObjectProperty(None) player2\",\n \"self.pos # Update - moving the ball by calling the move function and\",\n \"Vector(4, 0).rotate(randint(0, 360)) def update(self, dt): self.ball.move() # Bounce off top and bottom\",\n \"+= 1 # Bounce off right and increase the score if self.ball.x >\",\n \"the screen after touching it # on_touch_move() - when we drag our finger\",\n \"/ 4: self.player1.center_y = touch.y if touch.x > self.width * 3 / 4:\",\n \"App from kivy.uix.widget import Widget from kivy.properties import NumericProperty, ReferenceListProperty, ObjectProperty from kivy.vector\",\n \"# Bounce off top and bottom Y if (self.ball.y < 0) or (self.ball.y\",\n \"ball.velocity_x *= -1 print('hello world') class PongBall(Widget): velocity_x = NumericProperty(0) velocity_y = NumericProperty(0)\",\n \"50: self.ball.velocity_x *= -1 self.player2.score += 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def on_touch_move(self, touch): if\",\n \"Widget from kivy.properties import NumericProperty, ReferenceListProperty, ObjectProperty from kivy.vector import Vector from kivy.clock\",\n \"class PongApp(App): def build(self): game = PongGame() game.serve_ball() Clock.schedule_interval(game.update, 1.0 / 60.0) return\",\n \"def build(self): game = PongGame() game.serve_ball() Clock.schedule_interval(game.update, 1.0 / 60.0) return game PongApp().run()\",\n \"the App # Step 2 - Create the Game # Step 3 -\",\n \"from kivy.clock import Clock from random import randint class PongPaddle(Widget): score = NumericProperty(0)\",\n \"self.height - 50): self.ball.velocity_y *= -1.1 # Bounce off left and increase th\",\n \"* 3 / 4: self.player2.center_y = touch.y class PongApp(App): def build(self): game =\",\n \"and increase th score if self.ball.x < 0: self.ball.velocity_x *= -1 self.player1.score +=\",\n \"th score if self.ball.x < 0: self.ball.velocity_x *= -1 self.player1.score += 1 #\",\n \"he screen # on touch_up() - when we lift our finger off the\",\n \"we lift our finger off the screen after touching it # on_touch_move() -\",\n \"if touch.x < self.width / 1 / 4: self.player1.center_y = touch.y if touch.x\",\n \"bottom Y if (self.ball.y < 0) or (self.ball.y > self.height - 50): self.ball.velocity_y\",\n \"velocity_x = NumericProperty(0) velocity_y = NumericProperty(0) velocity = ReferenceListProperty(velocity_x, velocity_y) # Latest Position\",\n \"NumericProperty(0) def bounce_ball(self, ball): if self.collide_widget(ball): ball.velocity_x *= -1 print('hello world') class PongBall(Widget):\",\n \"of the Ball = Current Velocity + Current Position def move(self): self.pos =\",\n \"the Ball = Current Velocity + Current Position def move(self): self.pos = Vector(*self.velocity)\",\n \"*= -1 print('hello world') class PongBall(Widget): velocity_x = NumericProperty(0) velocity_y = NumericProperty(0) velocity\",\n \"def on_touch_move(self, touch): if touch.x < self.width / 1 / 4: self.player1.center_y =\",\n \"Step 4 - Run the App \\\"\\\"\\\" from kivy.app import App from kivy.uix.widget\",\n \"kivy.app import App from kivy.uix.widget import Widget from kivy.properties import NumericProperty, ReferenceListProperty, ObjectProperty\",\n \"4 - Run the App \\\"\\\"\\\" from kivy.app import App from kivy.uix.widget import\",\n \"Update - moving the ball by calling the move function and other stuff\",\n \"the Game # Step 3 - Build the Game # Step 4 -\",\n \"-1 print('hello world') class PongBall(Widget): velocity_x = NumericProperty(0) velocity_y = NumericProperty(0) velocity =\",\n \"world') class PongBall(Widget): velocity_x = NumericProperty(0) velocity_y = NumericProperty(0) velocity = ReferenceListProperty(velocity_x, velocity_y)\",\n \"- when we drag our finger on the screen class PongGame(Widget): ball =\",\n \"1 # Bounce off right and increase the score if self.ball.x > self.width\",\n \"touch): if touch.x < self.width / 1 / 4: self.player1.center_y = touch.y if\",\n \"# on touch_up() - when we lift our finger off the screen after\",\n \"< 0) or (self.ball.y > self.height - 50): self.ball.velocity_y *= -1.1 # Bounce\",\n \"if self.ball.x < 0: self.ball.velocity_x *= -1 self.player1.score += 1 # Bounce off\",\n \"on the screen class PongGame(Widget): ball = ObjectProperty(None) player1 = ObjectProperty(None) player2 =\",\n \"our fingers/mouse touches he screen # on touch_up() - when we lift our\",\n \"ball): if self.collide_widget(ball): ball.velocity_x *= -1 print('hello world') class PongBall(Widget): velocity_x = NumericProperty(0)\",\n \"NumericProperty(0) velocity_y = NumericProperty(0) velocity = ReferenceListProperty(velocity_x, velocity_y) # Latest Position of the\",\n \"def update(self, dt): self.ball.move() # Bounce off top and bottom Y if (self.ball.y\",\n \"*= -1 self.player1.score += 1 # Bounce off right and increase the score\",\n \"0: self.ball.velocity_x *= -1 self.player1.score += 1 # Bounce off right and increase\",\n \"from kivy.properties import NumericProperty, ReferenceListProperty, ObjectProperty from kivy.vector import Vector from kivy.clock import\",\n \"right and increase the score if self.ball.x > self.width - 50: self.ball.velocity_x *=\",\n \"we drag our finger on the screen class PongGame(Widget): ball = ObjectProperty(None) player1\",\n \"\\\"\\\"\\\" from kivy.app import App from kivy.uix.widget import Widget from kivy.properties import NumericProperty,\",\n \"from kivy.app import App from kivy.uix.widget import Widget from kivy.properties import NumericProperty, ReferenceListProperty,\",\n \"player2 = ObjectProperty(None) def serve_ball(self): self.ball.velocity = Vector(4, 0).rotate(randint(0, 360)) def update(self, dt):\",\n \"0) or (self.ball.y > self.height - 50): self.ball.velocity_y *= -1.1 # Bounce off\",\n \"Y if (self.ball.y < 0) or (self.ball.y > self.height - 50): self.ball.velocity_y *=\",\n \"+ Current Position def move(self): self.pos = Vector(*self.velocity) + self.pos # Update -\",\n \"kivy.uix.widget import Widget from kivy.properties import NumericProperty, ReferenceListProperty, ObjectProperty from kivy.vector import Vector\",\n \"PongApp(App): def build(self): game = PongGame() game.serve_ball() Clock.schedule_interval(game.update, 1.0 / 60.0) return game\",\n \"-1 self.player2.score += 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def on_touch_move(self, touch): if touch.x < self.width\",\n \"when we drag our finger on the screen class PongGame(Widget): ball = ObjectProperty(None)\",\n \"velocity_y = NumericProperty(0) velocity = ReferenceListProperty(velocity_x, velocity_y) # Latest Position of the Ball\",\n \"import Clock from random import randint class PongPaddle(Widget): score = NumericProperty(0) def bounce_ball(self,\",\n \"Create the App # Step 2 - Create the Game # Step 3\",\n \"import App from kivy.uix.widget import Widget from kivy.properties import NumericProperty, ReferenceListProperty, ObjectProperty from\",\n \"stuff # on touch_down() = When our fingers/mouse touches he screen # on\",\n \"it # on_touch_move() - when we drag our finger on the screen class\",\n \"from kivy.vector import Vector from kivy.clock import Clock from random import randint class\",\n \"class PongBall(Widget): velocity_x = NumericProperty(0) velocity_y = NumericProperty(0) velocity = ReferenceListProperty(velocity_x, velocity_y) #\",\n \"> self.height - 50): self.ball.velocity_y *= -1.1 # Bounce off left and increase\",\n \"Ball = Current Velocity + Current Position def move(self): self.pos = Vector(*self.velocity) +\",\n \"= Vector(4, 0).rotate(randint(0, 360)) def update(self, dt): self.ball.move() # Bounce off top and\",\n \"ObjectProperty(None) def serve_ball(self): self.ball.velocity = Vector(4, 0).rotate(randint(0, 360)) def update(self, dt): self.ball.move() #\",\n \"on touch_down() = When our fingers/mouse touches he screen # on touch_up() -\",\n \"self.ball.move() # Bounce off top and bottom Y if (self.ball.y < 0) or\",\n \"= NumericProperty(0) velocity_y = NumericProperty(0) velocity = ReferenceListProperty(velocity_x, velocity_y) # Latest Position of\",\n \"self.width * 3 / 4: self.player2.center_y = touch.y class PongApp(App): def build(self): game\",\n \"App # Step 2 - Create the Game # Step 3 - Build\",\n \"print('hello world') class PongBall(Widget): velocity_x = NumericProperty(0) velocity_y = NumericProperty(0) velocity = ReferenceListProperty(velocity_x,\",\n \"= ObjectProperty(None) player1 = ObjectProperty(None) player2 = ObjectProperty(None) def serve_ball(self): self.ball.velocity = Vector(4,\",\n \"self.player1.score += 1 # Bounce off right and increase the score if self.ball.x\",\n \"= ObjectProperty(None) def serve_ball(self): self.ball.velocity = Vector(4, 0).rotate(randint(0, 360)) def update(self, dt): self.ball.move()\",\n \"function and other stuff # on touch_down() = When our fingers/mouse touches he\",\n \"if (self.ball.y < 0) or (self.ball.y > self.height - 50): self.ball.velocity_y *= -1.1\",\n \"touching it # on_touch_move() - when we drag our finger on the screen\",\n \"increase the score if self.ball.x > self.width - 50: self.ball.velocity_x *= -1 self.player2.score\",\n \"< 0: self.ball.velocity_x *= -1 self.player1.score += 1 # Bounce off right and\",\n \"- 50): self.ball.velocity_y *= -1.1 # Bounce off left and increase th score\",\n \"/ 4: self.player2.center_y = touch.y class PongApp(App): def build(self): game = PongGame() game.serve_ball()\",\n \"serve_ball(self): self.ball.velocity = Vector(4, 0).rotate(randint(0, 360)) def update(self, dt): self.ball.move() # Bounce off\",\n \"(self.ball.y < 0) or (self.ball.y > self.height - 50): self.ball.velocity_y *= -1.1 #\",\n \"touch_up() - when we lift our finger off the screen after touching it\",\n \"off top and bottom Y if (self.ball.y < 0) or (self.ball.y > self.height\",\n \"ObjectProperty(None) player1 = ObjectProperty(None) player2 = ObjectProperty(None) def serve_ball(self): self.ball.velocity = Vector(4, 0).rotate(randint(0,\",\n \"self.ball.velocity = Vector(4, 0).rotate(randint(0, 360)) def update(self, dt): self.ball.move() # Bounce off top\",\n \"kivy.clock import Clock from random import randint class PongPaddle(Widget): score = NumericProperty(0) def\",\n \"Step 2 - Create the Game # Step 3 - Build the Game\",\n \"and increase the score if self.ball.x > self.width - 50: self.ball.velocity_x *= -1\",\n \"-1.1 # Bounce off left and increase th score if self.ball.x < 0:\",\n \"4: self.player1.center_y = touch.y if touch.x > self.width * 3 / 4: self.player2.center_y\",\n \"screen class PongGame(Widget): ball = ObjectProperty(None) player1 = ObjectProperty(None) player2 = ObjectProperty(None) def\",\n \"- Create the App # Step 2 - Create the Game # Step\",\n \"kivy.vector import Vector from kivy.clock import Clock from random import randint class PongPaddle(Widget):\",\n \"calling the move function and other stuff # on touch_down() = When our\",\n \"\\\"\\\"\\\" # Step 1 - Create the App # Step 2 - Create\",\n \"and other stuff # on touch_down() = When our fingers/mouse touches he screen\",\n \"off the screen after touching it # on_touch_move() - when we drag our\",\n \"and bottom Y if (self.ball.y < 0) or (self.ball.y > self.height - 50):\",\n \"Game # Step 3 - Build the Game # Step 4 - Run\",\n \"= NumericProperty(0) velocity = ReferenceListProperty(velocity_x, velocity_y) # Latest Position of the Ball =\",\n \"randint class PongPaddle(Widget): score = NumericProperty(0) def bounce_ball(self, ball): if self.collide_widget(ball): ball.velocity_x *=\",\n \"screen after touching it # on_touch_move() - when we drag our finger on\",\n \"update(self, dt): self.ball.move() # Bounce off top and bottom Y if (self.ball.y <\",\n \"our finger off the screen after touching it # on_touch_move() - when we\",\n \"finger off the screen after touching it # on_touch_move() - when we drag\",\n \"move function and other stuff # on touch_down() = When our fingers/mouse touches\",\n \"score if self.ball.x > self.width - 50: self.ball.velocity_x *= -1 self.player2.score += 1\",\n \"self.pos = Vector(*self.velocity) + self.pos # Update - moving the ball by calling\",\n \"import randint class PongPaddle(Widget): score = NumericProperty(0) def bounce_ball(self, ball): if self.collide_widget(ball): ball.velocity_x\",\n \"Position def move(self): self.pos = Vector(*self.velocity) + self.pos # Update - moving the\",\n \"3 - Build the Game # Step 4 - Run the App \\\"\\\"\\\"\",\n \"fingers/mouse touches he screen # on touch_up() - when we lift our finger\",\n \"Bounce off left and increase th score if self.ball.x < 0: self.ball.velocity_x *=\",\n \"self.ball.velocity_x *= -1 self.player1.score += 1 # Bounce off right and increase the\",\n \"+ self.pos # Update - moving the ball by calling the move function\",\n \"def move(self): self.pos = Vector(*self.velocity) + self.pos # Update - moving the ball\",\n \"1 - Create the App # Step 2 - Create the Game #\",\n \"self.player2.score += 1 self.player1.bounce_ball(self.ball) self.player2.bounce_ball(self.ball) def on_touch_move(self, touch): if touch.x < self.width /\",\n \"by calling the move function and other stuff # on touch_down() = When\",\n \"Vector from kivy.clock import Clock from random import randint class PongPaddle(Widget): score =\",\n \"- Run the App \\\"\\\"\\\" from kivy.app import App from kivy.uix.widget import Widget\",\n \"= touch.y class PongApp(App): def build(self): game = PongGame() game.serve_ball() Clock.schedule_interval(game.update, 1.0 /\",\n \"# Step 1 - Create the App # Step 2 - Create the\",\n \"ObjectProperty from kivy.vector import Vector from kivy.clock import Clock from random import randint\"\n]","isConversational":false}}},{"rowIdx":3997,"cells":{"ngram":{"kind":"list like","value":["class SceneRelation: def __init__(self): self.on_ground = set() self.on_block = {} self.clear = set()","SceneRelation: def __init__(self): self.on_ground = set() self.on_block = {} self.clear = set() def","= set() self.on_block = {} self.clear = set() def print_relation(self): print(self.on_ground) print(self.on_block) print(self.clear)","self.on_ground = set() self.on_block = {} self.clear = set() def print_relation(self): print(self.on_ground) print(self.on_block)","def __init__(self): self.on_ground = set() self.on_block = {} self.clear = set() def print_relation(self):","__init__(self): self.on_ground = set() self.on_block = {} self.clear = set() def print_relation(self): print(self.on_ground)"],"string":"[\n \"class SceneRelation: def __init__(self): self.on_ground = set() self.on_block = {} self.clear = set()\",\n \"SceneRelation: def __init__(self): self.on_ground = set() self.on_block = {} self.clear = set() def\",\n \"= set() self.on_block = {} self.clear = set() def print_relation(self): print(self.on_ground) print(self.on_block) print(self.clear)\",\n \"self.on_ground = set() self.on_block = {} self.clear = set() def print_relation(self): print(self.on_ground) print(self.on_block)\",\n \"def __init__(self): self.on_ground = set() self.on_block = {} self.clear = set() def print_relation(self):\",\n \"__init__(self): self.on_ground = set() self.on_block = {} self.clear = set() def print_relation(self): print(self.on_ground)\"\n]","isConversational":false}}},{"rowIdx":3998,"cells":{"ngram":{"kind":"list like","value":["0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card.","they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY","== 12: p += 4 elif card % 13 == 11: p +=","'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52","checks if the agent plays a higher card even though their partner is","+ \"_Game_Data_Avg_Train-\" + str(t) + \".csv\", 'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba","AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3)","datetime.datetime.now() print(\"Runtime: \", end_time - start_time) # runtime if __name__ == \"__main__\": main()","cards hands[1] = East's cards hands[2] = Agent's cards hands[3] = West's cards","to 1 such that every card has an equal chance of being chosen.","the highest card already played is higher than theirs. \"\"\" def highest_card(self, valid_cards,","are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \"","-1: return # highest card played so far is higher than agent's highest","ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx])","1): policy = [] count = 0 for x in ba.weights: y =","and 25 since a Diamond 13 and Diamond 14 will beat the Diamond","for the last game, determine and write out policy if ba and game","f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\")","agent is declarer if points[0] + points[2] > points[1] + points[3] and points[2]","self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1","in range(4): card = None player_idx = (round_winner + player) % 4 if","# We initialize all weights to 1 such that every card has an","np.argmax(y) while max in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count","count_points(hands): points = [] for hand in hands: p = 0 for card","+ 1) * 13) if i in cards_in_hand] if len(valid_cards) == 0: return","states have been updated for this game # For each round for _","+ 1} / \", end=\"\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc","k.write( f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\"","Ace is 12, 25, 38, 51 \"\"\" def count_points(hands): points = [] for","(suit + 1) * 13)) valid_cards = np.array([i for i in all_valid_cards if","as an integer: Cards 0 -> 12 are Club 2 -> Club 14","wins. We want to incrase the proportion with which we play 24. ba.add_win(state,","2 # agent is not declarer and agent should start the play return","# 3 cards played and agent has higher cards, does it play highest","round If 4th card is not 25, then the agent wins. We want","1 \"\"\" EXAMPLE state = State(1, set(23, 0)) # Diamond 12, Club 2","= np.zeros(3) \"\"\" This function checks if the agent plays their highest card","# TESTING -- we don't change the weights here print(f\"TESTING on {NUM_GAMES_TEST} games\")","from collections import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \"Card\" as an","\"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52 # Agent","values at indices 24 and 25 since a Diamond 13 and Diamond 14","== max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\" This function checks if","\"\"\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for idx, card","have been updated for this game # For each round for _ in","example, with state = (1, set(23, 0)), weights[state] will likely have very large","p = 0 for card in hand: if card % 13 == 12:","if ba and game == (NUM_GAMES_TRAIN - 1): policy = [] count =","max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card >","cards in round card_played = 24 # Diamond 13 <-- 3rd card in","Diamond 12 and Club 2 with an opening suit of Diamonds. The agent","three cards played already and the agent has at least one higher card","hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1","game == (NUM_GAMES_TRAIN - 1): policy = [] count = 0 for x","card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\" This function checks","-> 25 are Diamond 2 -> Diamond 14 Cards 26 -> 38 are","5,000,000 self.game_num = 1 \"\"\" EXAMPLE state = State(1, set(23, 0)) # Diamond","guaranteed to win. \"\"\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played)","{average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" + str(t) + \".csv\", 'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\"","rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with","frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0]","Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY FUNCTIONS","highest card, does agent play lowest card? do they beat their partner? self.partner_win(valid_cards,","agent_card_played[1]) # for the last game, determine and write out policy if ba","at the end of the data training phase. \"\"\" def write_policy(self, cards_in_hand, policy,","(1, set(23, 0)), weights[state] will likely have very large values at indices 24","large values at indices 24 and 25 since a Diamond 13 and Diamond","np.array([i for i in range(suit * 13, (suit + 1) * 13) if","Club 2 with an opening suit of Diamonds. The agent is 3rd to","None agent_state_2 = None opening_suit = -1 # Each player plays a card","self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state =","the valid card with highest weight. # index_into_valid_counts = 1 since 20 has","this to be positive): {average_win_delta}\") print(f\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\") print(f\"Average","as f: for state in self.weights: f.write(\"State: suit {} | cards played {}","points[2] > points[1] + points[3] and points[2] > points[0]: return True, 2 #","card, cards_played, partners_cards) # 3 cards played + partner has played highest card,","card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS,","13, (suit + 1) * 13) if i in cards_in_hand]) if len(valid_cards) ==","24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1]","13 rounds of 1 NT bridge and outputs a winner. \"\"\" def play_game(game,","every card has an equal chance of being chosen. self.weights = {} self.weights[State(-1,","13, (suit + 1) * 13) if i in cards_in_hand] if len(valid_cards) ==","if i in hands[player_idx]]) if suit == -1: return # highest card played","declarer_idx) \"\"\" def agent_declarer(hands): points = count_points(hands) # determines the number of points","barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: # if agent","== 0: print(f\"{game + 1} / \", end=\"\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random","NT bridge and outputs a winner. \"\"\" def play_game(game, hands, train=False, ba=None, barf=None):","1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card","\"\"\" EXAMPLE state = State(1, set(23, 0)) card_played = 24 If 4th card","start_time = datetime.datetime.now() hands = [] # TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN} games\") ba","higher cards, does it play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards,","so far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3","= 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while","is 3 Representing a \"State\" as an opening suit and frozenset of up","round for _ in range(13): cards_played = [] agent_card_played = [-1, -1] agent_state","with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" + str(t) + \".csv\", 'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\")","3rd to play a card and must play a Diamond if it has","cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) %","{} | partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count","end of the data training phase. \"\"\" def write_policy(self, cards_in_hand, policy, filename, states_accessed):","ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx])","cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards = [i for i in","agent partnership states_accessed = [] # records which states have been updated for","index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24","OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function plays 13 rounds of 1 NT","every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) -","is 0 Diamonds is 1 Hearts is 2 Spades is 3 Representing a","<-- used in a \"State\" where no cards have been played yet. Clubs","self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995 # 100,000 self.alpha =","in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards):","STATS_PER == 0: print(f\"{game + 1} / \", end=\"\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS","= 0.9999995 # 5,000,000 self.game_num = 1 \"\"\" EXAMPLE state = State(1, set(23,","\"\"\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit = 1","the number of points in each hand # agent's partnership has more points","+ str(t) + \".csv\", 'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def main():","(round_winner + player) % 4 if player_idx == 2: # Agent plays if","\"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY A SINGLE GAME OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This","self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1","0.9995 # 10,000 # self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 #","= datetime.datetime.now() hands = [] # TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN} games\") ba =","+ 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") #","the proportion with which we play 24. ba.add_loss(state, card_played) \"\"\" def add_loss(self, state,","game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf)","agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and write","state.partners_card, policy[count])) if state in states_accessed: g.write(\"State: suit {} | cards played {}","+= 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\" This function checks for any red flags","even though their partner is guaranteed to win. \"\"\" def partner_win(self, valid_cards, agent_valid_cards,","be positive): {average_win_delta}\") print(f\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\") print(f\"Average Red Flag","= card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: #","points. Return: (agent_is_declarer, declarer_idx) \"\"\" def agent_declarer(hands): points = count_points(hands) # determines the","is at that state. In this example, with state = (1, set(23, 0)),","20 has a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards =","13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) +","barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for","np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) #","ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card","The agent choose to play whichever remaining card has the highest weight. The","def play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit = 1 suit","if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the","game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\"Runtime: \", end_time - start_time) # runtime","in range(suit * 13, (suit + 1) * 13) if i in cards_in_hand]","def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards)","[] agent_card_played = [-1, -1] agent_state = None agent_state_2 = None opening_suit =","{NUM_GAMES_TRAIN} games\") ba = BridgeAgent() ba = game_summary(ba, True) # TESTING -- we","str(t) + \".csv\", 'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def main(): start_time","13 <-- 3rd card in round If 4th card is not 25, then","Hearts is 2 Spades is 3 Representing a \"State\" as an opening suit","hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game,","[] for hand in hands: p = 0 for card in hand: if","phase. \"\"\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename","238 Final Project: Bridge RL Agent <NAME> & <NAME> \"\"\" import copy import","frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards)","winner of the round. \"\"\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val =","if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2,","player_idx == 2: # Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1])","highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3","max_val, max_idx = card, idx return max_idx \"\"\" This function determines the declarer","np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in range(52): for card_2 in","** self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) card_played = 24 If","agent plays their highest card even though the highest card already played is","agent_state = None agent_state_2 = None opening_suit = -1 # Each player plays","= None player_idx = (round_winner + player) % 4 if player_idx == 2:","if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and write out","11, 20, 24, 38) The agent choose to play whichever remaining card has","== 2: # Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state)","y[max] = -1 max = np.argmax(y) policy.append(max) count += 1 game_file = \"Bridge_\"","'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions deals random cards. \"\"\" deck = list(range(52)) def shuffle_cards():","card_played = 24 If 4th card is 25 (Diamond 14), then the agent","barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta (want this to be positive):","= 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995","open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'a') as k: k.write( f\"{game +","= 24 return valid_cards[index_into_valid_cards] \"\"\" This function write the policy at the end","which states have been updated for this game # For each round for","to be positive): {average_win_delta}\") print(f\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\") print(f\"Average Red","outputs a winner. \"\"\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0])","a card and must play a Diamond if it has one. Representing the","\"\"\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \"\"\"","cards_played) + round_winner) % 4 # Adjust the BridgeAgent weights. # If the","print(f\"TRAINING on {NUM_GAMES_TRAIN} games\") ba = BridgeAgent() ba = game_summary(ba, True) # TESTING","card % 13 == 10: p += 2 elif card % 13 ==","functions deals random cards. \"\"\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13],","+= 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\"","range(card_1, 52): for card_3 in range(card_2, 52): for card_partner in [-1, card_1, card_2,","= 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def __init__(self):","Representing a \"State\" as an opening suit and frozenset of up to 3","(suit + 1) * 13) if i in cards_in_hand]) if len(valid_cards) == 0:","class BridgeAgent: def __init__(self): # We initialize all weights to 1 such that","weights. # If the BridgeAgent or N wins. if round_winner == 0 or","1 \"\"\" This function checks if the agent wins a round when there's","namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS","most points. Return: (agent_is_declarer, declarer_idx) \"\"\" def agent_declarer(hands): points = count_points(hands) # determines","1) * 13) if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards =","__init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT","is not declarer and agent should start the play return False, -1 \"\"\"","import datetime import numpy as np import random from collections import namedtuple \"\"\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''","by non-agents who play randomly. \"\"\" def play_random_card(suit, cards_in_hand): if suit == -1:","partnership with the most points. Return: (agent_is_declarer, declarer_idx) \"\"\" def agent_declarer(hands): points =","'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def __init__(self): # We initialize all weights to 1 such","that every card has an equal chance of being chosen. self.weights = {}","= cards_in_hand # Choose the valid card with highest weight. # index_into_valid_counts =","count += 1 game_file = \"Bridge_\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file,","return max_idx \"\"\" This function determines the declarer based on partnership with the","given that it is at that state. In this example, with state =","a \"State\" where no cards have been played yet. Clubs is 0 Diamonds","play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot plays card = play_random_card(opening_suit,","BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function plays 13 rounds of 1 NT bridge","for this game # For each round for _ in range(13): cards_played =","player plays a card in order starting from round_winner for player in range(4):","want to incrase the proportion with which we play 24. ba.add_win(state, card_played) \"\"\"","card, does agent play lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards,","52 cards given that it is at that state. In this example, with","i in range(suit * 13, (suit + 1) * 13) if i in","= card, idx return max_idx \"\"\" This function determines the declarer based on","barf=barf_random) ba.game_num += 1 if (game + 1) % STATS_PER == 0: print(f\"{game","Club 2 -> Club 14 Cards 13 -> 25 are Diamond 2 ->","is 14 Representing a \"Suit\" as an integer: n/a is -1 <-- used","decrease the proportion with which we play 24. ba.add_loss(state, card_played) \"\"\" def add_loss(self,","k: k.write( f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\"","the array of length-52 represets the proportion with which the agent should play","hand # agent's partnership has more points and agent is declarer if points[0]","BridgeAgent weights. # If the BridgeAgent or N wins. if round_winner == 0","def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for idx, card in","barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'a') as k: k.write(","24 and 25 since a Diamond 13 and Diamond 14 will beat the","'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52 #","1) % 4 # the person to the right of the declarer starts","Diamonds is 1 Hearts is 2 Spades is 3 Representing a \"State\" as","Diamond 13 and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State =","[0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True,","are Heart 2 -> Heart 14 Cards 39 -> 51 are Spade 2","barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \"\"\" hands[0]","{} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1","the weights here print(f\"TESTING on {NUM_GAMES_TEST} games\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now()","+ \".txt\", 'w') as f: for state in self.weights: f.write(\"State: suit {} |","+= play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game + 1) %","and frozenset of up to 3 \"Card\"-s: state = State(1, frozenset(23, 0)) We","= game_summary(ba, True) # TESTING -- we don't change the weights here print(f\"TESTING","\"\"\" This function determines the winner of the round. \"\"\" def determine_round_winner(suit, cards_played):","play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit = 1 suit =","EXAMPLE state = State(1, set(23, 0)) card_played = 24 If 4th card is","+ round_winner) % 4 # Adjust the BridgeAgent weights. # If the BridgeAgent","policy at the end of the data training phase. \"\"\" def write_policy(self, cards_in_hand,","bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit.","\" \" TRACKS PERFORMANCE OF BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def __init__(self):","barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER)","# records which states have been updated for this game # For each","which we play 24. ba.add_win(state, card_played) \"\"\" def add_win(self, state, card_played): self.weights[state][card_played] *=","= count_points(hands) # determines the number of points in each hand # agent's","# Following the EXAMPLE: # suit = 1 suit = state.opening_suit # valid_cards","Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \"","all_valid_cards if i in hands[player_idx]]) if suit == -1: return # highest card","If 4th card is 25 (Diamond 14), then the agent loses. We want","partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards","cards given that it is at that state. In this example, with state","1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions deals random","1) * 13) if i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand)","p += 1 points.append(p) return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS PERFORMANCE OF BRIDGE","the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust","points[2] > points[0]: return True, 2 # agent is not declarer and agent","= {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for","for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in","\" RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def __init__(self): # We initialize all","very large values at indices 24 and 25 since a Diamond 13 and","f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def main(): start_time = datetime.datetime.now() hands = [] # TRAINING","Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\"State: suit","== 10: p += 2 elif card % 13 == 9: p +=","likely have very large values at indices 24 and 25 since a Diamond","at indices 24 and 25 since a Diamond 13 and Diamond 14 will","at that state. In this example, with state = (1, set(23, 0)), weights[state]","GAME OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function plays 13 rounds of 1","else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of","+= 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\"","= np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in range(52): for card_2","= np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def","np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3)","weight. # index_into_valid_counts = 1 since 20 has a smaller weight than 24.","# agent's partnership has more points and agent is declarer if points[0] +","1 \"\"\" This function checks for any red flags based on what the","Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening","self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in","deck[26:39], deck[39:52]] \"\"\" This function is used by non-agents who play randomly. \"\"\"","= -1 max = np.argmax(y) policy.append(max) count += 1 game_file = \"Bridge_\" +","in states_accessed: g.write(\"State: suit {} | cards played {} | partner's card {}\\nBest","-1 \"\"\" This function counts the points in each hand. Note: Ace is","declarer, d = agent_declarer(hands) \"\"\" hands[0] = North's cards hands[1] = East's cards","opening_suit in range(4): for card_1 in range(52): for card_2 in range(card_1, 52): for","played yet. Clubs is 0 Diamonds is 1 Hearts is 2 Spades is","BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game in","Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT =","plays their highest card even though the highest card already played is higher","function determines the winner of the round. \"\"\" def determine_round_winner(suit, cards_played): max_idx =","14 Cards 39 -> 51 are Spade 2 -> Spade 14 Jack is","as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def main(): start_time = datetime.datetime.now() hands =","hands: p = 0 for card in hand: if card % 13 ==","agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1","points.append(p) return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS PERFORMANCE OF BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\"","def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards):","is higher than theirs. \"\"\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) >","= 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL AGENT","partners_cards) # 3 cards played + partner has played highest card, does agent","= barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" +","> points[1] + points[3] and points[2] > points[0]: return True, 2 # agent","weight. card_played = ba.play_card(state, cards_in_hand) \"\"\" def play_card(self, state, cards_in_hand): # Following the","round. \"\"\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for idx,","set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11, 20, 24, 38) The","based on what the agent played. \"\"\" def assess_card_played(self, hands, card, suit, cards_played,","with a Map from a \"State\" to an array of length-52: We call","has played highest card, does agent play lowest card? do they beat their","hand in hands: p = 0 for card in hand: if card %","points = [] for hand in hands: p = 0 for card in","partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY A SINGLE GAME","opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner","Agent can choose any card to play (only some are valid). NUM_GAMES_TRAIN =","1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] +=","# 5,000,000 self.game_num = 1 \"\"\" EXAMPLE state = State(1, set(23, 0)) #","p += 4 elif card % 13 == 11: p += 3 elif","card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: # if agent is","hands = [] # TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN} games\") ba = BridgeAgent() ba","highest card even though the highest card already played is higher than theirs.","BridgeAgent: def __init__(self): # We initialize all weights to 1 such that every","not 25, then the agent wins. We want to incrase the proportion with","the most points. Return: (agent_is_declarer, declarer_idx) \"\"\" def agent_declarer(hands): points = count_points(hands) #","the agent loses. We want to decrease the proportion with which we play","\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def __init__(self): # We initialize all weights to 1","Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 #","1} / \", end=\"\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc =","of the opening suit. if player == 0: opening_suit = card // 13","play each of the 52 cards given that it is at that state.","in each hand. Note: Ace is 12, 25, 38, 51 \"\"\" def count_points(hands):","cards_in_hand) \"\"\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit =","play return False, -1 \"\"\" This function counts the points in each hand.","= np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS =","the declarer starts the game NS_Wins = 0 # used to count total","def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \"\"\" This function is used","39 -> 51 are Spade 2 -> Spade 14 Jack is 11 Queen","ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) +","card even though the highest card already played is higher than theirs. \"\"\"","cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) >","ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and","Red Flag Ratios - Agent: {average_rf_ratios_agent}\") print(f\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\")","'w') as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf =","card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card =","opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: # if agent is declarer,","in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the valid","King is 13 Ace is 14 Representing a \"Suit\" as an integer: n/a","for any red flags based on what the agent played. \"\"\" def assess_card_played(self,","(1 + 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1, set(23,","card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000","suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1) *","Win Delta (want this to be positive): {average_win_delta}\") print(f\"Average Red Flag Ratios -","on what the agent played. \"\"\" def assess_card_played(self, hands, card, suit, cards_played, player_idx,","3 cards played and agent has higher cards, does it play highest card","one higher card than what's been played. \"\"\" def higher_card(self, valid_cards, agent_valid_cards, card,","card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed:","[deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \"\"\" This function is used by non-agents who play","right of the declarer starts the game NS_Wins = 0 # used to","== 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning","OF BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT","their highest card even though the highest card already played is higher than","return random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\" This function determines the winner of the round.","Diamond if it has one. Representing the MDP with a Map from a","Note: Ace is 12, 25, 38, 51 \"\"\" def count_points(hands): points = []","And the array of length-52 represets the proportion with which the agent should","it has Diamonds. In this example, agent will most likely play 24, which","= Agent's cards hands[3] = West's cards \"\"\" round_winner = (d + 1)","whichever remaining card has the highest weight. The agent must play a Diamond","for card_partner in [-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2,","-> Diamond 14 Cards 26 -> 38 are Heart 2 -> Heart 14","FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions deals random cards. \"\"\" deck = list(range(52))","self.weights: f.write(\"State: suit {} | cards played {} | partner's card {}\\nBest Card","-1 # Each player plays a card in order starting from round_winner for","frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in range(52):","= np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta (want this to be positive): {average_win_delta}\") print(f\"Average","agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else:","we don't change the weights here print(f\"TESTING on {NUM_GAMES_TEST} games\") game_summary(ba, False, iterations=NUM_GAMES_TEST)","points[1] + points[3] and points[2] > points[0]: return True, 2 # agent is","elif card % 13 == 10: p += 2 elif card % 13","declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0])","or N wins. if round_winner == 0 or round_winner == 2: if ba","play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d","== -1: return random.choice(cards_in_hand) valid_cards = [i for i in range(suit * 13,","wins. if round_winner == 0 or round_winner == 2: if ba and train:","any card to play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST =","= 10000 STATS_PER = 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class","enumerate(cards_played): if suit * 13 <= card < (suit + 1) * 13","is 3rd to play a card and must play a Diamond if it","declarer based on partnership with the most points. Return: (agent_is_declarer, declarer_idx) \"\"\" def","highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent has higher","hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit +","for player in range(4): card = None player_idx = (round_winner + player) %","is not 25, then the agent wins. We want to incrase the proportion","on {NUM_GAMES_TRAIN} games\") ba = BridgeAgent() ba = game_summary(ba, True) # TESTING --","has a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards]","0 with open(filename + \"_Last_Game.txt\", 'w') as g: g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand)) with","+ points[3] and points[2] > points[0]: return True, 2 # agent is not","\"\"\" This function checks if the agent wins a round when there's three","checks if the agent wins a round when there's three cards played already","agent_card_played[1] = card else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx]) #","\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52 # Agent can choose any card to play","# determines the number of points in each hand # agent's partnership has","= card else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep","agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit,","opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997","card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state","1 such that every card has an equal chance of being chosen. self.weights","13 == 12: p += 4 elif card % 13 == 11: p","agent's partnership has more points and agent is declarer if points[0] + points[2]","valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] +=","state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE","g: g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename + \".txt\", 'w') as f: for","len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\" This function determines the winner","# agent is not declarer and agent should start the play return False,","): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] +=","self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \"\"\" EXAMPLE state = State(1,","write the policy at the end of the data training phase. \"\"\" def","rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'a') as","when there's three cards played already and the agent has at least one","2 <-- first 2 cards in round card_played = 24 # Diamond 13","<NAME> & <NAME> \"\"\" import copy import datetime import numpy as np import","[] count = 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max =","if card % 13 == 12: p += 4 elif card % 13","== 9: p += 1 points.append(p) return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS PERFORMANCE","\".csv\", 'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def main(): start_time = datetime.datetime.now()","{average_rf_ratios_agent}\") print(f\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" +","\"\"\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha **","Bridge RL Agent <NAME> & <NAME> \"\"\" import copy import datetime import numpy","play 24. ba.add_win(state, card_played) \"\"\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 +","13 == 9: p += 1 points.append(p) return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS","== (NUM_GAMES_TRAIN - 1): policy = [] count = 0 for x in","Spade 2 -> Spade 14 Jack is 11 Queen is 12 King is","= np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \"\"\" This","weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) #","self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) card_played = 24","rounds of 1 NT bridge and outputs a winner. \"\"\" def play_game(game, hands,","for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba,","\".txt\", 'w') as f: for state in self.weights: f.write(\"State: suit {} | cards","card < (suit + 1) * 13 and card > max_val: max_val, max_idx","| partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count +=","We have a Diamond 12 and Club 2 with an opening suit of","barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent","declarer, they play their partner's cards if ba and declarer: agent_state_2 = State(opening_suit,","a winner. \"\"\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards","1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def __init__(self): #","= 0.997 # 1,000 # self.alpha = 0.9995 # 10,000 # self.alpha =","= [0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands),","= namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\"","rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\"","len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1","\"\"\" This functions deals random cards. \"\"\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck)","the opening suit. if player == 0: opening_suit = card // 13 hands[player_idx].remove(card)","* self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand =","max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\" This function checks if the","print(f\"Average Win Delta (want this to be positive): {average_win_delta}\") print(f\"Average Red Flag Ratios","A SINGLE GAME OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function plays 13 rounds","/ \", end=\"\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT","in hands[player_idx]]) if suit == -1: return # highest card played so far","* STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta","# index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] =","State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE SOME CONSTANTS \"","rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) +","2 -> Club 14 Cards 13 -> 25 are Diamond 2 -> Diamond","(want this to be positive): {average_win_delta}\") print(f\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\")","== 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins","Agent: {average_rf_ratios_agent}\") print(f\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\"","= play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit. if player ==","State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha =","cards. \"\"\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]]","highest card already played is higher than theirs. \"\"\" def highest_card(self, valid_cards, agent_valid_cards,","if suit == -1: return # highest card played so far is higher","card % 13 == 11: p += 3 elif card % 13 ==","DEFINE SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52 # Agent can choose any","function checks if the agent plays their highest card even though the highest","card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit. if player","\" DEFINE SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52 # Agent can choose","want to decrease the proportion with which we play 24. ba.add_loss(state, card_played) \"\"\"","self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1","_ in range(13): cards_played = [] agent_card_played = [-1, -1] agent_state = None","= BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game","agent has higher cards, does it play highest card or highest necessary card?","0.997 # 1,000 # self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995","+= 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2]","weights to 1 such that every card has an equal chance of being","random.choice(cards_in_hand) valid_cards = [i for i in range(suit * 13, (suit + 1)","function checks for any red flags based on what the agent played. \"\"\"","from a \"State\" to an array of length-52: We call this Map \"weights\".","This function checks if the agent plays their highest card even though the","0 or round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer:","-1: return random.choice(cards_in_hand) valid_cards = [i for i in range(suit * 13, (suit","\"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins =","and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game,","state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE","\"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0]","if agent is declarer, they play their partner's cards if ba and declarer:","52): for card_partner in [-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1,","should play each of the 52 cards given that it is at that","than what's been played. \"\"\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if","in hand: if card % 13 == 12: p += 4 elif card","hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1]","this example, with state = (1, set(23, 0)), weights[state] will likely have very","barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] =","card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] =","card is not 25, then the agent wins. We want to incrase the","11: p += 3 elif card % 13 == 10: p += 2","red flags based on what the agent played. \"\"\" def assess_card_played(self, hands, card,","hands[player_idx]) agent_card_played[1] = card else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx])","card in order starting from round_winner for player in range(4): card = None","# Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT","cards played {} | partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card,","\"weights\". And the array of length-52 represets the proportion with which the agent","import random from collections import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \"Card\"","play 24. ba.add_loss(state, card_played) \"\"\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 +","= 0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num = 1","= np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\" This function checks if the agent plays","card and must play a Diamond if it has one. Representing the MDP","def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards)","based on partnership with the most points. Return: (agent_is_declarer, declarer_idx) \"\"\" def agent_declarer(hands):","state = (1, set(23, 0)), weights[state] will likely have very large values at","suit. if player == 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) #","np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\" This","25, then the agent wins. We want to incrase the proportion with which","\"_Game_Data_Train-\" + str(t) + \".csv\", 'w') as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\"","(suit + 1) * 13) if i in cards_in_hand] if len(valid_cards) == 0:","from round_winner for player in range(4): card = None player_idx = (round_winner +","print(f\"TESTING on {NUM_GAMES_TEST} games\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\"Runtime: \", end_time","1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) #","played is higher than theirs. \"\"\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards)","self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\" This function checks if the agent","cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the valid card","\"\"\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and","= datetime.datetime.now() print(\"Runtime: \", end_time - start_time) # runtime if __name__ == \"__main__\":","higher card even though their partner is guaranteed to win. \"\"\" def partner_win(self,","k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags() barf_random =","with open(filename + \".txt\", 'w') as f: for state in self.weights: f.write(\"State: suit","return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS PERFORMANCE OF BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class","10,000 # self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 #","and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State', ['opening_suit',","return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) +","card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: # if","in range(52): for card_2 in range(card_1, 52): for card_3 in range(card_2, 52): for","NS_Wins = 0 # used to count total wins in agent partnership states_accessed","self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3)","= ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card,","24. ba.add_win(state, card_played) \"\"\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1","player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random","open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" + str(t) + \".csv\", 'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return","train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if","higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) >","State(1, set(23, 0)) # Diamond 12, Club 2 <-- first 2 cards in","[] # TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN} games\") ba = BridgeAgent() ba = game_summary(ba,","of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for","cards hands[3] = West's cards \"\"\" round_winner = (d + 1) % 4","(Diamond 14), then the agent loses. We want to decrease the proportion with","card_played) \"\"\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha","frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 #","partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot","To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY","if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\" This function","and agent has higher cards, does it play highest card or highest necessary","cards_in_hand # Choose the valid card with highest weight. # index_into_valid_counts = 1","the game NS_Wins = 0 # used to count total wins in agent","self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS","if state in states_accessed: g.write(\"State: suit {} | cards played {} | partner's","self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\" This function checks if the agent","p += 2 elif card % 13 == 9: p += 1 points.append(p)","n/a is -1 <-- used in a \"State\" where no cards have been","* 13)) valid_cards = np.array([i for i in all_valid_cards if i in cards_played])","that it is at that state. In this example, with state = (1,","iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'w') as k: k.write(\"game,\"","more points and agent is declarer if points[0] + points[2] > points[1] +","to an array of length-52: We call this Map \"weights\". And the array","since a Diamond 13 and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\"","<filename>bridge_RL_agent_v16.py \"\"\" CS 238 Final Project: Bridge RL Agent <NAME> & <NAME> \"\"\"","max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card","\"\"\" hands[0] = North's cards hands[1] = East's cards hands[2] = Agent's cards","to count total wins in agent partnership states_accessed = [] # records which","as an integer: n/a is -1 <-- used in a \"State\" where no","13 and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State',","len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ):","\"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def __init__(self): # We","cards hands[2] = Agent's cards hands[3] = West's cards \"\"\" round_winner = (d","range(4): card = None player_idx = (round_winner + player) % 4 if player_idx","card, idx return max_idx \"\"\" This function determines the declarer based on partnership","> max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0]","suit {} | cards played {} | partner's card {}\\nBest Card To Play:","14 Representing a \"Suit\" as an integer: n/a is -1 <-- used in","play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num +=","0)) # Diamond 12, Club 2 <-- first 2 cards in round card_played","card than what's been played. \"\"\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards):","\"\"\" This function checks if the agent plays a higher card even though","if round_winner == 0 or round_winner == 2: if ba and train: ba.add_win(agent_state,","play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx","0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max","> 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1","and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1","AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def __init__(self): # We initialize all weights to","1 game_file = \"Bridge_\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return","if i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\"","in round If 4th card is not 25, then the agent wins. We","SINGLE GAME OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function plays 13 rounds of","person to the right of the declarer starts the game NS_Wins = 0","some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \"\"\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''","cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards) in","with which the agent should play each of the 52 cards given that","\"\"\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename +","an integer: n/a is -1 <-- used in a \"State\" where no cards","EXAMPLE state = State(1, set(23, 0)) # Diamond 12, Club 2 <-- first","cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY A SINGLE GAME OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\"","= State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha","51 \"\"\" def count_points(hands): points = [] for hand in hands: p =","determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for idx, card in enumerate(cards_played):","round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the BridgeAgent weights.","partnership states_accessed = [] # records which states have been updated for this","set(23, 0)) card_played = 24 If 4th card is 25 (Diamond 14), then","suit = 1 suit = state.opening_suit # valid_cards = [20, 24] valid_cards =","\"\"\" This function plays 13 rounds of 1 NT bridge and outputs a","add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num) \"\"\"","suit of Diamonds. The agent is 3rd to play a card and must","highest card played so far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards,","For each round for _ in range(13): cards_played = [] agent_card_played = [-1,","if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else:","and write out policy if ba and game == (NUM_GAMES_TRAIN - 1): policy","elif player_idx == 0: # if agent is declarer, they play their partner's","RL Agent <NAME> & <NAME> \"\"\" import copy import datetime import numpy as","games\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\"Runtime: \", end_time - start_time) #","NUM_ACTIONS = 52 # Agent can choose any card to play (only some","# used to count total wins in agent partnership states_accessed = [] #","agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0:","valid_cards = cards_in_hand # Choose the valid card with highest weight. # index_into_valid_counts","partner has played highest card, does agent play lowest card? do they beat","shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \"\"\" This function is used by","== 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\" This function determines the winner of","returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \"\"\" This function write the policy at","__init__(self): # We initialize all weights to 1 such that every card has","higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and","in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count += 1 game_file","-1 max_val = -1 for idx, card in enumerate(cards_played): if suit * 13","the agent plays their highest card even though the highest card already played","policy.append(max) count += 1 game_file = \"Bridge_\" + str(game + 1) ba.write_policy(agents_cards, policy,","this example, agent will most likely play 24, which beats 23 <-- hopefully","card in round If 4th card is not 25, then the agent wins.","card in enumerate(cards_played): if suit * 13 <= card < (suit + 1)","number of points in each hand # agent's partnership has more points and","= State(1, set(23, 0)) # Diamond 12, Club 2 <-- first 2 cards","# the person to the right of the declarer starts the game NS_Wins","first 2 cards in round card_played = 24 # Diamond 13 <-- 3rd","2 cards in round card_played = 24 # Diamond 13 <-- 3rd card","with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'w') as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\"","= [0] NS_Wins_random = [0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1]","None player_idx = (round_winner + player) % 4 if player_idx == 2: #","BridgeAgent() ba = game_summary(ba, True) # TESTING -- we don't change the weights","training phase. \"\"\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with","higher than theirs. \"\"\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1","\"\"\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and","if the agent wins a round when there's three cards played already and","with state = (1, set(23, 0)), weights[state] will likely have very large values","'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def main(): start_time = datetime.datetime.now() hands","> max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] +=","which the agent should play each of the 52 cards given that it","will most likely play 24, which beats 23 <-- hopefully 24 has the","card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands,","* 13, (suit + 1) * 13)) valid_cards = np.array([i for i in","cards \"\"\" round_winner = (d + 1) % 4 # the person to","// 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played)","\"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins","integer: Cards 0 -> 12 are Club 2 -> Club 14 Cards 13","0 Diamonds is 1 Hearts is 2 Spades is 3 Representing a \"State\"","\"\"\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2])","1,000 # self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995 # 100,000","# 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \"\"\" EXAMPLE","valid_cards[index_into_valid_cards] \"\"\" This function write the policy at the end of the data","Club 2 <-- first 2 cards in round card_played = 24 # Diamond","agent has at least one higher card than what's been played. \"\"\" def","for card in hand: if card % 13 == 12: p += 4","partner's cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card","card_2 in range(card_1, 52): for card_3 in range(card_2, 52): for card_partner in [-1,","* 13 <= card < (suit + 1) * 13 and card >","what's been played. \"\"\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played)","play their partner's cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0])","player in range(4): card = None player_idx = (round_winner + player) % 4","is declarer if points[0] + points[2] > points[1] + points[3] and points[2] >","checks for any red flags based on what the agent played. \"\"\" def","count_points(hands) # determines the number of points in each hand # agent's partnership","checks if the agent plays their highest card even though the highest card","def agent_declarer(hands): points = count_points(hands) # determines the number of points in each","# 10,000 # self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000","in range(suit * 13, (suit + 1) * 13) if i in cards_in_hand])","we play 24. ba.add_win(state, card_played) \"\"\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1","Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\"State: suit {} |","max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\" This function checks if the","numpy as np import random from collections import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE","deals random cards. \"\"\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26],","can choose any card to play (only some are valid). NUM_GAMES_TRAIN = 10000","has at least one higher card than what's been played. \"\"\" def higher_card(self,","np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self):","range(52): for card_2 in range(card_1, 52): for card_3 in range(card_2, 52): for card_partner","partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2]","incrase the proportion with which we play 24. ba.add_win(state, card_played) \"\"\" def add_win(self,","+= 1 \"\"\" This function checks for any red flags based on what","max_idx = -1 max_val = -1 for idx, card in enumerate(cards_played): if suit","hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d =","This function plays 13 rounds of 1 NT bridge and outputs a winner.","in all_valid_cards if i in hands[player_idx]]) if suit == -1: return # highest","1 since 20 has a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards])","-1 for idx, card in enumerate(cards_played): if suit * 13 <= card <","namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \"Card\" as an integer: Cards 0","games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) *","state, cards_in_hand): # Following the EXAMPLE: # suit = 1 suit = state.opening_suit","if it has one. Representing the MDP with a Map from a \"State\"","for i in all_valid_cards if i in hands[player_idx]]) if suit == -1: return","of length-52: We call this Map \"weights\". And the array of length-52 represets","are Club 2 -> Club 14 Cards 13 -> 25 are Diamond 2","suit and frozenset of up to 3 \"Card\"-s: state = State(1, frozenset(23, 0))","don't change the weights here print(f\"TESTING on {NUM_GAMES_TEST} games\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time","hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played,","in agent partnership states_accessed = [] # records which states have been updated","Cards 13 -> 25 are Diamond 2 -> Diamond 14 Cards 26 ->","13)) valid_cards = np.array([i for i in all_valid_cards if i in cards_played]) agent_valid_cards","f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative statistics","return ba def main(): start_time = datetime.datetime.now() hands = [] # TRAINING print(f\"TRAINING","player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1) * 13)) valid_cards","+= 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1]","Spade 14 Jack is 11 Queen is 12 King is 13 Ace is","Keep track of the opening suit. if player == 0: opening_suit = card","initialize all weights to 1 such that every card has an equal chance","then the agent wins. We want to incrase the proportion with which we","state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) #","1.0) # self.alpha = 0.997 # 1,000 # self.alpha = 0.9995 # 10,000","Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state,","+ \".csv\", 'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def main(): start_time =","Cards 39 -> 51 are Spade 2 -> Spade 14 Jack is 11","self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative","flags based on what the agent played. \"\"\" def assess_card_played(self, hands, card, suit,","been played. \"\"\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) ==","BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game in range(iterations): hands =","self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1","to incrase the proportion with which we play 24. ba.add_win(state, card_played) \"\"\" def","STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1)","what the agent played. \"\"\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards):","partners_cards) elif player_idx == 0: # if agent is declarer, they play their","does it play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played,","being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit","self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\" This function checks if the agent plays a higher","= [-1, -1] agent_state = None agent_state_2 = None opening_suit = -1 #","<= card < (suit + 1) * 13 and card > max_val: max_val,","suit = state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i for i","self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num =","suit * 13 <= card < (suit + 1) * 13 and card","= np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta (want this to","np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta (want this to be positive): {average_win_delta}\") print(f\"Average Red","= East's cards hands[2] = Agent's cards hands[3] = West's cards \"\"\" round_winner","declarer and agent should start the play return False, -1 \"\"\" This function","agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \"\"\" hands[0] = North's cards hands[1]","opening_suit = -1 # Each player plays a card in order starting from","): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] +=","the points in each hand. Note: Ace is 12, 25, 38, 51 \"\"\"","BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) #","\"\"\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit *","# returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \"\"\" This function write the policy","here print(f\"TESTING on {NUM_GAMES_TEST} games\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\"Runtime: \",","the 52 cards given that it is at that state. In this example,","\"Card\" as an integer: Cards 0 -> 12 are Club 2 -> Club","ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max] =","NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS,","= None opening_suit = -1 # Each player plays a card in order","4 # Adjust the BridgeAgent weights. # If the BridgeAgent or N wins.","has more points and agent is declarer if points[0] + points[2] > points[1]","1 suit = state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i for","last game, determine and write out policy if ba and game == (NUM_GAMES_TRAIN","self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4):","| cards played {} | partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played,","13 <= card < (suit + 1) * 13 and card > max_val:","Following the EXAMPLE: # suit = 1 suit = state.opening_suit # valid_cards =","self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1","'a') as k: k.write( f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\"","or round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2,","# suit = 1 suit = state.opening_suit # valid_cards = [20, 24] valid_cards","- Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" + str(t) + \".csv\", 'w') as","+ 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with","play whichever remaining card has the highest weight. The agent must play a","with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'a') as k: k.write( f\"{game","play randomly. \"\"\" def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards","remaining card has the highest weight. The agent must play a Diamond if","+= 2 elif card % 13 == 9: p += 1 points.append(p) return","valid_cards = np.array([i for i in all_valid_cards if i in cards_played]) agent_valid_cards =","100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num","the BridgeAgent or N wins. if round_winner == 0 or round_winner == 2:","ba = BridgeAgent() ba = game_summary(ba, True) # TESTING -- we don't change","valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \"\"\" This function write the policy at the","start the play return False, -1 \"\"\" This function counts the points in","proportion with which we play 24. ba.add_win(state, card_played) \"\"\" def add_win(self, state, card_played):","NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL","= state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i for i in","a \"Card\" as an integer: Cards 0 -> 12 are Club 2 ->","round_winner for player in range(4): card = None player_idx = (round_winner + player)","agent wins a round when there's three cards played already and the agent","if suit == -1: return random.choice(cards_in_hand) valid_cards = [i for i in range(suit","out policy if ba and game == (NUM_GAMES_TRAIN - 1): policy = []","0 -> 12 are Club 2 -> Club 14 Cards 13 -> 25","+= 4 elif card % 13 == 11: p += 3 elif card","ba=None, barf=barf_random) ba.game_num += 1 if (game + 1) % STATS_PER == 0:","# Adjust the BridgeAgent weights. # If the BridgeAgent or N wins. if","% 13 == 10: p += 2 elif card % 13 == 9:","play a card and must play a Diamond if it has one. Representing","in hands: p = 0 for card in hand: if card % 13","round when there's three cards played already and the agent has at least","and card > max_val: max_val, max_idx = card, idx return max_idx \"\"\" This","function determines the declarer based on partnership with the most points. Return: (agent_is_declarer,","N wins. if round_winner == 0 or round_winner == 2: if ba and","card % 13 == 9: p += 1 points.append(p) return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \"","agent is declarer, they play their partner's cards if ba and declarer: agent_state_2","+= 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\" This function checks if the agent wins","updated for this game # For each round for _ in range(13): cards_played","change the weights here print(f\"TESTING on {NUM_GAMES_TEST} games\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time =","+= 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0]","return random.choice(cards_in_hand) valid_cards = [i for i in range(suit * 13, (suit +","# Agent can choose any card to play (only some are valid). NUM_GAMES_TRAIN","= [] # records which states have been updated for this game #","= State(1, frozenset(23, 0)) We have a Diamond 12 and Club 2 with","it is at that state. In this example, with state = (1, set(23,","if player_idx == 2: # Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played),","f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative statistics on red flags for every STATS_PER games.","else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx,","13 Ace is 14 Representing a \"Suit\" as an integer: n/a is -1","agent should play each of the 52 cards given that it is at","(game + 1) % STATS_PER == 0: print(f\"{game + 1} / \", end=\"\",","2 Spades is 3 Representing a \"State\" as an opening suit and frozenset","if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] +=","valid card with highest weight. # index_into_valid_counts = 1 since 20 has a","= 0 # used to count total wins in agent partnership states_accessed =","ba.game_num += 1 if (game + 1) % STATS_PER == 0: print(f\"{game +","= agent_declarer(hands) \"\"\" hands[0] = North's cards hands[1] = East's cards hands[2] =","We call this Map \"weights\". And the array of length-52 represets the proportion","count += 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions","def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13,","BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT =","player_idx == 0: # if agent is declarer, they play their partner's cards","card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state","chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in","+ 1) * 13 and card > max_val: max_val, max_idx = card, idx","card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \"\"\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''","than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns","BridgeAgent or N wins. if round_winner == 0 or round_winner == 2: if","np import random from collections import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a","Return: (agent_is_declarer, declarer_idx) \"\"\" def agent_declarer(hands): points = count_points(hands) # determines the number","copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \"\"\" hands[0] = North's cards","cards played and agent has higher cards, does it play highest card or","This function checks for any red flags based on what the agent played.","# self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995 # 100,000 self.alpha","cards_played, player_idx, partners_cards) elif player_idx == 0: # if agent is declarer, they","[20, 24] valid_cards = np.array([i for i in range(suit * 13, (suit +","state = State(1, set(23, 0)) card_played = 24 If 4th card is 25","though the highest card already played is higher than theirs. \"\"\" def highest_card(self,","flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT","card_1 in range(52): for card_2 in range(card_1, 52): for card_3 in range(card_2, 52):","valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1","choose any card to play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST","track of the opening suit. if player == 0: opening_suit = card //","opening suit and frozenset of up to 3 \"Card\"-s: state = State(1, frozenset(23,","[-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state]","f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative statistics on red flags for every","ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \"\"\"","NS_Wins = [0] NS_Wins_random = [0] for game in range(iterations): hands = shuffle_cards()","+ str(t) + \".csv\", 'a') as k: k.write( f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] -","def __init__(self): # We initialize all weights to 1 such that every card","f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative statistics on red flags for every STATS_PER games. barf.clear_red_flags()","declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and write out policy","= play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot plays card =","agent play lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played,","<-- 3rd card in round If 4th card is not 25, then the","play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit. if player == 0:","the data training phase. \"\"\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count =","14 Jack is 11 Queen is 12 King is 13 Ace is 14","red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random))","game_file = \"Bridge_\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins","in round card_played = 24 # Diamond 13 <-- 3rd card in round","is 12 King is 13 Ace is 14 Representing a \"Suit\" as an","return # highest card played so far is higher than agent's highest card","for state in self.weights: f.write(\"State: suit {} | cards played {} | partner's","\"Bridge_\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba,","range(4): for card_1 in range(52): for card_2 in range(card_1, 52): for card_3 in","str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN):","We want to incrase the proportion with which we play 24. ba.add_win(state, card_played)","and agent should start the play return False, -1 \"\"\" This function counts","range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] +=","agent should start the play return False, -1 \"\"\" This function counts the","card = None player_idx = (round_winner + player) % 4 if player_idx ==","k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags() barf_random","def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename + \"_Last_Game.txt\",","# 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000","determines the number of points in each hand # agent's partnership has more","-1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in range(52): for","points in each hand. Note: Ace is 12, 25, 38, 51 \"\"\" def","card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent has higher cards,","self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) card_played = 24 If 4th","np.zeros(3) \"\"\" This function checks if the agent plays their highest card even","\"_Game_Data_Train-\" + str(t) + \".csv\", 'a') as k: k.write( f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1]","\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS","data training phase. \"\"\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0","then the agent loses. We want to decrease the proportion with which we","max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1]","wins in agent partnership states_accessed = [] # records which states have been","# index_into_valid_counts = 1 since 20 has a smaller weight than 24. #","round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1])","that state. In this example, with state = (1, set(23, 0)), weights[state] will","{} | cards played {} | partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit,","not declarer and agent should start the play return False, -1 \"\"\" This","i in all_valid_cards if i in hands[player_idx]]) if suit == -1: return #","NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent =","# TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN} games\") ba = BridgeAgent() ba = game_summary(ba, True)","card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played + partner has","4 elif card % 13 == 11: p += 3 elif card %","Ace is 14 Representing a \"Suit\" as an integer: n/a is -1 <--","max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\" This function checks for any","write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename + \"_Last_Game.txt\", 'w')","{NUM_GAMES_TEST} games\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\"Runtime: \", end_time - start_time)","38, 51 \"\"\" def count_points(hands): points = [] for hand in hands: p","TESTING -- we don't change the weights here print(f\"TESTING on {NUM_GAMES_TEST} games\") game_summary(ba,","proportion with which the agent should play each of the 52 cards given","= copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \"\"\" hands[0] = North's","card % 13 == 12: p += 4 elif card % 13 ==","Project: Bridge RL Agent <NAME> & <NAME> \"\"\" import copy import datetime import","play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game + 1) % STATS_PER","0 for card in hand: if card % 13 == 12: p +=","set(23, 0)), weights[state] will likely have very large values at indices 24 and","all weights to 1 such that every card has an equal chance of","for card_1 in range(52): for card_2 in range(card_1, 52): for card_3 in range(card_2,","at least one higher card than what's been played. \"\"\" def higher_card(self, valid_cards,","1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if","return True, 2 # agent is not declarer and agent should start the","elif card % 13 == 11: p += 3 elif card % 13","barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t)","to the right of the declarer starts the game NS_Wins = 0 #","necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played + partner","has Diamonds. In this example, agent will most likely play 24, which beats","+ \"_Game_Data_Train-\" + str(t) + \".csv\", 'a') as k: k.write( f\"{game + 1},\"","i in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for i in","Each player plays a card in order starting from round_winner for player in","game_summary(ba, True) # TESTING -- we don't change the weights here print(f\"TESTING on","points and agent is declarer if points[0] + points[2] > points[1] + points[3]","if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\" This function","NS_Wins_random = [0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game,","4th card is 25 (Diamond 14), then the agent loses. We want to","PLAY A SINGLE GAME OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function plays 13","if points[0] + points[2] > points[1] + points[3] and points[2] > points[0]: return","\"\"\" This function write the policy at the end of the data training","return valid_cards[index_into_valid_cards] \"\"\" This function write the policy at the end of the","train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine","function counts the points in each hand. Note: Ace is 12, 25, 38,","Map from a \"State\" to an array of length-52: We call this Map","class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3)","on {NUM_GAMES_TEST} games\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\"Runtime: \", end_time -","train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands)","12, 25, 38, 51 \"\"\" def count_points(hands): points = [] for hand in","agent must play a Diamond if it has Diamonds. In this example, agent","1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] +=","Heart 2 -> Heart 14 Cards 39 -> 51 are Spade 2 ->","If 4th card is not 25, then the agent wins. We want to","+ \".csv\", 'a') as k: k.write( f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\"","to play a card and must play a Diamond if it has one.","\" \" DEFINE SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52 # Agent can","agent loses. We want to decrease the proportion with which we play 24.","This function checks if the agent wins a round when there's three cards","self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha =","3 cards played + partner has played highest card, does agent play lowest","# self.alpha = 0.997 # 1,000 # self.alpha = 0.9995 # 10,000 #","weights here print(f\"TESTING on {NUM_GAMES_TEST} games\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\"Runtime:","game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'w') as","of the data training phase. \"\"\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count","= np.argmax(y) while max in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max)","highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played +","24 # Diamond 13 <-- 3rd card in round If 4th card is","range(suit * 13, (suit + 1) * 13) if i in cards_in_hand] if","ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and write out policy if","(len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2]","OF BRIDGE Representing a \"Card\" as an integer: Cards 0 -> 12 are","Representing the MDP with a Map from a \"State\" to an array of","\"\"\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8,","= 0 with open(filename + \"_Last_Game.txt\", 'w') as g: g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand))","x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count += 1 game_file =","statistics on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta","copy import datetime import numpy as np import random from collections import namedtuple","-> Club 14 Cards 13 -> 25 are Diamond 2 -> Diamond 14","play a Diamond if it has one. Representing the MDP with a Map","as k: k.write( f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\"","38) The agent choose to play whichever remaining card has the highest weight.","lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \"\"\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''","the highest weight. card_played = ba.play_card(state, cards_in_hand) \"\"\" def play_card(self, state, cards_in_hand): #","agent_card_played[1]) NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer:","We initialize all weights to 1 such that every card has an equal","+= 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\"","function is used by non-agents who play randomly. \"\"\" def play_random_card(suit, cards_in_hand): if","partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY A SINGLE GAME OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\"","TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN} games\") ba = BridgeAgent() ba = game_summary(ba, True) #","\" \" RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def __init__(self): # We initialize","declarer starts the game NS_Wins = 0 # used to count total wins","list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \"\"\" This function is","max_idx = card, idx return max_idx \"\"\" This function determines the declarer based","policy[count])) if state in states_accessed: g.write(\"State: suit {} | cards played {} |","= np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3)","24, 38) The agent choose to play whichever remaining card has the highest","= shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands,","cards_played): max_idx = -1 max_val = -1 for idx, card in enumerate(cards_played): if","= barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\",","partner is guaranteed to win. \"\"\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards):","add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num) \"\"\"","played. \"\"\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3","the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \"","Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\" This function checks","order starting from round_winner for player in range(4): card = None player_idx =","open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'w') as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\"","12 and Club 2 with an opening suit of Diamonds. The agent is","# 1,000 # self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995 #","will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \"\"\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''","= np.array([i for i in all_valid_cards if i in hands[player_idx]]) if suit ==","\"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \"Card\" as an integer: Cards 0 ->","- 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average","{}\\n\\n\".format(cards_in_hand)) with open(filename + \".txt\", 'w') as f: for state in self.weights: f.write(\"State:","the agent wins. We want to incrase the proportion with which we play","in range(4): for card_1 in range(52): for card_2 in range(card_1, 52): for card_3","# Diamond 12, Club 2 <-- first 2 cards in round card_played =","This functions deals random cards. \"\"\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return","= 24 # Diamond 13 <-- 3rd card in round If 4th card","and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card","i in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if i in","import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \"Card\" as an integer: Cards","12 are Club 2 -> Club 14 Cards 13 -> 25 are Diamond","each round for _ in range(13): cards_played = [] agent_card_played = [-1, -1]","and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if","This function checks if the agent plays a higher card even though their","ba and game == (NUM_GAMES_TRAIN - 1): policy = [] count = 0","- Agent: {average_rf_ratios_agent}\") print(f\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) +","barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'a')","idx return max_idx \"\"\" This function determines the declarer based on partnership with","# highest card played so far is higher than agent's highest card self.highest_card(valid_cards,","*= (1 + 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1,","% 13 == 9: p += 1 points.append(p) return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \"","agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent has","self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state =","in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max]","with which we play 24. ba.add_loss(state, card_played) \"\"\" def add_loss(self, state, card_played): self.weights[state][card_played]","['opening_suit', 'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS =","Diamonds. The agent is 3rd to play a card and must play a","(agent_is_declarer, declarer_idx) \"\"\" def agent_declarer(hands): points = count_points(hands) # determines the number of","= 52 # Agent can choose any card to play (only some are","= BridgeAgent() ba = game_summary(ba, True) # TESTING -- we don't change the","np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards]","in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards):","This function write the policy at the end of the data training phase.","already played is higher than theirs. \"\"\" def highest_card(self, valid_cards, agent_valid_cards, card): if","which we play 24. ba.add_loss(state, card_played) \"\"\" def add_loss(self, state, card_played): self.weights[state][card_played] /=","card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \"","range(suit * 13, (suit + 1) * 13) if i in cards_in_hand]) if","state.cards_played, state.partners_card, policy[count])) count += 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\"","((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT)","open(filename + \"_Last_Game.txt\", 'w') as g: g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename +","{} | partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if","** self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0, 1,","Clubs is 0 Diamonds is 1 Hearts is 2 Spades is 3 Representing","24 return valid_cards[index_into_valid_cards] \"\"\" This function write the policy at the end of","== 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not","= (d + 1) % 4 # the person to the right of","partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) >","with the most points. Return: (agent_is_declarer, declarer_idx) \"\"\" def agent_declarer(hands): points = count_points(hands)","cards played already and the agent has at least one higher card than","False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\"Runtime: \", end_time - start_time) # runtime if","Jack is 11 Queen is 12 King is 13 Ace is 14 Representing","3 elif card % 13 == 10: p += 2 elif card %","card_played = 24 # Diamond 13 <-- 3rd card in round If 4th","np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\" This function checks if the agent plays their","if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1","cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1) * 13))","of up to 3 \"Card\"-s: state = State(1, frozenset(23, 0)) We have a","than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent","else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for","= card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner =","Representing a \"Suit\" as an integer: n/a is -1 <-- used in a","# Keep track of the opening suit. if player == 0: opening_suit =","State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11, 20, 24, 38)","Diamond 13 <-- 3rd card in round If 4th card is not 25,","loses. We want to decrease the proportion with which we play 24. ba.add_loss(state,","partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards)","10000 STATS_PER = 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent:","hand. Note: Ace is 12, 25, 38, 51 \"\"\" def count_points(hands): points =","1.0) for opening_suit in range(4): for card_1 in range(52): for card_2 in range(card_1,","as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags()","their partner is guaranteed to win. \"\"\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played,","max_val: max_val, max_idx = card, idx return max_idx \"\"\" This function determines the","def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative","= -1 # Each player plays a card in order starting from round_winner","played so far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) #","player) % 4 if player_idx == 2: # Agent plays if ba: agent_state","is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played","do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \"","np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 # self.alpha = 0.9995 #","play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER =","\"\"\" round_winner = (d + 1) % 4 # the person to the","def main(): start_time = datetime.datetime.now() hands = [] # TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN}","Flag Ratios - Agent: {average_rf_ratios_agent}\") print(f\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\") with","card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards)","+ partner has played highest card, does agent play lowest card? do they","opening suit of Diamonds. The agent is 3rd to play a card and","-> 12 are Club 2 -> Club 14 Cards 13 -> 25 are","24] valid_cards = np.array([i for i in range(suit * 13, (suit + 1)","cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: #","if player == 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get","Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" + str(t) + \".csv\", 'w') as m:","2 -> Heart 14 Cards 39 -> 51 are Spade 2 -> Spade","= 1 since 20 has a smaller weight than 24. # index_into_valid_cards =","Ratios - Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" + str(t) + \".csv\", 'w')","should start the play return False, -1 \"\"\" This function counts the points","plays a card in order starting from round_winner for player in range(4): card","is 2 Spades is 3 Representing a \"State\" as an opening suit and","np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta (want this to be","cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if i in hands[player_idx]]) if","for i in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for i","this game # For each round for _ in range(13): cards_played = []","points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS PERFORMANCE OF BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags:","-1 <-- used in a \"State\" where no cards have been played yet.","This function counts the points in each hand. Note: Ace is 12, 25,","agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and","52): for card_3 in range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]:","agent wins. We want to incrase the proportion with which we play 24.","= list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \"\"\" This function","in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1]","> 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if","barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta (want this to be positive): {average_win_delta}\") print(f\"Average Red Flag","* 13, (suit + 1) * 13) if i in cards_in_hand] if len(valid_cards)","14 Cards 26 -> 38 are Heart 2 -> Heart 14 Cards 39","+= 1 if (game + 1) % STATS_PER == 0: print(f\"{game + 1}","round card_played = 24 # Diamond 13 <-- 3rd card in round If","m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def main(): start_time = datetime.datetime.now() hands = []","+ \"_Last_Game.txt\", 'w') as g: g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename + \".txt\",","if the agent plays a higher card even though their partner is guaranteed","positive): {average_win_delta}\") print(f\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\") print(f\"Average Red Flag Ratios","copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max] = -1 max =","ba.add_loss(state, card_played) \"\"\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 *","one. Representing the MDP with a Map from a \"State\" to an array","{}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY FUNCTIONS \"","highest weight. card_played = ba.play_card(state, cards_in_hand) \"\"\" def play_card(self, state, cards_in_hand): # Following","the declarer based on partnership with the most points. Return: (agent_is_declarer, declarer_idx) \"\"\"","cards_played = [] agent_card_played = [-1, -1] agent_state = None agent_state_2 = None","+ 1) * 13) if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards","REPRESENTATIONS OF BRIDGE Representing a \"Card\" as an integer: Cards 0 -> 12","% 13 == 12: p += 4 elif card % 13 == 11:","13) if i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards)","25 (Diamond 14), then the agent loses. We want to decrease the proportion","card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0)","NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\",","length-52: We call this Map \"weights\". And the array of length-52 represets the","for card_3 in range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]: state","max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards):","winner. \"\"\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards =","> max_val: max_val, max_idx = card, idx return max_idx \"\"\" This function determines","= [] agent_card_played = [-1, -1] agent_state = None agent_state_2 = None opening_suit","round_winner = (d + 1) % 4 # the person to the right","for hand in hands: p = 0 for card in hand: if card","d = agent_declarer(hands) \"\"\" hands[0] = North's cards hands[1] = East's cards hands[2]","NUM_GAMES_TEST = 10000 STATS_PER = 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\"","counts the points in each hand. Note: Ace is 12, 25, 38, 51","'w') as f: for state in self.weights: f.write(\"State: suit {} | cards played","with highest weight. # index_into_valid_counts = 1 since 20 has a smaller weight","None opening_suit = -1 # Each player plays a card in order starting","round_winner == 0 or round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0])","The agent must play a Diamond if it has Diamonds. In this example,","= (round_winner + player) % 4 if player_idx == 2: # Agent plays","= [] # TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN} games\") ba = BridgeAgent() ba =","26 -> 38 are Heart 2 -> Heart 14 Cards 39 -> 51","1) * 13)) valid_cards = np.array([i for i in all_valid_cards if i in","== 0 or round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if","+ 1) % STATS_PER == 0: print(f\"{game + 1} / \", end=\"\", flush=True)","an opening suit and frozenset of up to 3 \"Card\"-s: state = State(1,","{average_win_delta}\") print(f\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\") print(f\"Average Red Flag Ratios -","-1 max = np.argmax(y) policy.append(max) count += 1 game_file = \"Bridge_\" + str(game","24 If 4th card is 25 (Diamond 14), then the agent loses. We","count = 0 with open(filename + \"_Last_Game.txt\", 'w') as g: g.write(\"Cards in Hand:","Flag Ratios - Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" + str(t) + \".csv\",","* 13) if i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return","deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \"\"\" This","+= 1 \"\"\" This function checks if the agent plays a higher card","This function is used by non-agents who play randomly. \"\"\" def play_random_card(suit, cards_in_hand):","as g: g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename + \".txt\", 'w') as f:","* 13, (suit + 1) * 13) if i in cards_in_hand]) if len(valid_cards)","12 King is 13 Ace is 14 Representing a \"Suit\" as an integer:","for card_2 in range(card_1, 52): for card_3 in range(card_2, 52): for card_partner in","points = count_points(hands) # determines the number of points in each hand #","This function determines the declarer based on partnership with the most points. Return:","function checks if the agent wins a round when there's three cards played","= np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return","Club 14 Cards 13 -> 25 are Diamond 2 -> Diamond 14 Cards","NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random)","state in self.weights: f.write(\"State: suit {} | cards played {} | partner's card","have been played yet. Clubs is 0 Diamonds is 1 Hearts is 2","to play whichever remaining card has the highest weight. The agent must play","datetime.datetime.now() hands = [] # TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN} games\") ba = BridgeAgent()","each hand # agent's partnership has more points and agent is declarer if","13 == 10: p += 2 elif card % 13 == 9: p","the policy at the end of the data training phase. \"\"\" def write_policy(self,","played + partner has played highest card, does agent play lowest card? do","highest weight. # index_into_valid_counts = 1 since 20 has a smaller weight than","agent choose to play whichever remaining card has the highest weight. The agent","Map \"weights\". And the array of length-52 represets the proportion with which the","1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\" This","elif card % 13 == 9: p += 1 points.append(p) return points \"\"\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''","function write the policy at the end of the data training phase. \"\"\"","1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\" This function checks if the agent wins a","CS 238 Final Project: Bridge RL Agent <NAME> & <NAME> \"\"\" import copy","declarer if points[0] + points[2] > points[1] + points[3] and points[2] > points[0]:","STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta (want","# Diamond 13 <-- 3rd card in round If 4th card is not","def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num)","1 NT bridge and outputs a winner. \"\"\" def play_game(game, hands, train=False, ba=None,","{}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\"State: suit {} | cards","agent plays a higher card even though their partner is guaranteed to win.","states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card","chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0)","self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\" This function checks for any red","CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52 # Agent can choose any card to","= None agent_state_2 = None opening_suit = -1 # Each player plays a","yet. Clubs is 0 Diamonds is 1 Hearts is 2 Spades is 3","State(1, frozenset(23, 0)) We have a Diamond 12 and Club 2 with an","1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \"\"\" EXAMPLE state","points[0]: return True, 2 # agent is not declarer and agent should start","states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card","open(filename + \".txt\", 'w') as f: for state in self.weights: f.write(\"State: suit {}","an equal chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] =","% 4 if player_idx == 2: # Agent plays if ba: agent_state =","has the highest weight. The agent must play a Diamond if it has","= list(range(suit * 13, (suit + 1) * 13)) valid_cards = np.array([i for","the winner of the round. \"\"\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val","self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1","max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] +=","+= 1 points.append(p) return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS PERFORMANCE OF BRIDGE AGENT","range(13): cards_played = [] agent_card_played = [-1, -1] agent_state = None agent_state_2 =","4, 8, 11, 20, 24, 38) The agent choose to play whichever remaining","Cards 0 -> 12 are Club 2 -> Club 14 Cards 13 ->","# Each player plays a card in order starting from round_winner for player","state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i for i in range(suit","13 -> 25 are Diamond 2 -> Diamond 14 Cards 26 -> 38","# Choose the valid card with highest weight. # index_into_valid_counts = 1 since","with which we play 24. ba.add_win(state, card_played) \"\"\" def add_win(self, state, card_played): self.weights[state][card_played]","average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT)","= -1 for idx, card in enumerate(cards_played): if suit * 13 <= card","p += 3 elif card % 13 == 10: p += 2 elif","where no cards have been played yet. Clubs is 0 Diamonds is 1","In this example, agent will most likely play 24, which beats 23 <--","a Map from a \"State\" to an array of length-52: We call this","starts the game NS_Wins = 0 # used to count total wins in","# Cumulative statistics on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0)","3 Representing a \"State\" as an opening suit and frozenset of up to","def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards = [i for","than theirs. \"\"\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and","def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'w')","& <NAME> \"\"\" import copy import datetime import numpy as np import random","have a Diamond 12 and Club 2 with an opening suit of Diamonds.","partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in","+ points[2] > points[1] + points[3] and points[2] > points[0]: return True, 2","max in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count += 1","beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY A","hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx ==","datetime import numpy as np import random from collections import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS","must play a Diamond if it has Diamonds. In this example, agent will","even though the highest card already played is higher than theirs. \"\"\" def","Diamond 14 Cards 26 -> 38 are Heart 2 -> Heart 14 Cards","self.game_num = 1 \"\"\" EXAMPLE state = State(1, set(23, 0)) # Diamond 12,","Agent <NAME> & <NAME> \"\"\" import copy import datetime import numpy as np","0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995 #","the highest weight. The agent must play a Diamond if it has Diamonds.","y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max] = -1","is declarer, they play their partner's cards if ba and declarer: agent_state_2 =","far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards","-> 38 are Heart 2 -> Heart 14 Cards 39 -> 51 are","call this Map \"weights\". And the array of length-52 represets the proportion with","1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] +=","has the highest weight. card_played = ba.play_card(state, cards_in_hand) \"\"\" def play_card(self, state, cards_in_hand):","though their partner is guaranteed to win. \"\"\" def partner_win(self, valid_cards, agent_valid_cards, card,","{}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \"","EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11,","\" \" PLAY A SINGLE GAME OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function","-- we don't change the weights here print(f\"TESTING on {NUM_GAMES_TEST} games\") game_summary(ba, False,","self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0,","(sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random =","agent is 3rd to play a card and must play a Diamond if","beats 23 <-- hopefully 24 has the highest weight. card_played = ba.play_card(state, cards_in_hand)","the play return False, -1 \"\"\" This function counts the points in each","card is 25 (Diamond 14), then the agent loses. We want to decrease","cards_in_hand): # Following the EXAMPLE: # suit = 1 suit = state.opening_suit #","partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1","0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) card_played","np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \"\"\" This function","agent will most likely play 24, which beats 23 <-- hopefully 24 has","BRIDGE Representing a \"Card\" as an integer: Cards 0 -> 12 are Club","player_idx = (round_winner + player) % 4 if player_idx == 2: # Agent","(NUM_GAMES_TRAIN - 1): policy = [] count = 0 for x in ba.weights:","barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game +","a \"State\" as an opening suit and frozenset of up to 3 \"Card\"-s:","NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2,","1 if (game + 1) % STATS_PER == 0: print(f\"{game + 1} /","card_3 in range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]: state =","# Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4","To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\"State: suit {}","the agent plays a higher card even though their partner is guaranteed to","in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\" This function","\" TRACKS PERFORMANCE OF BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS","ba = game_summary(ba, True) # TESTING -- we don't change the weights here","not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card <","\"\"\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha **","max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1","= 0 for card in hand: if card % 13 == 12: p","barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) +","a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] ==","13) if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand #","determines the winner of the round. \"\"\" def determine_round_winner(suit, cards_played): max_idx = -1","and must play a Diamond if it has one. Representing the MDP with","\"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random =","1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\" This function checks if the agent plays a","partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \"\"\" hands[0] =","are Spade 2 -> Spade 14 Jack is 11 Queen is 12 King","-> Spade 14 Jack is 11 Queen is 12 King is 13 Ace","Choose the valid card with highest weight. # index_into_valid_counts = 1 since 20","= barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'a') as k:","policy, filename, states_accessed): count = 0 with open(filename + \"_Last_Game.txt\", 'w') as g:","| partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state","in [-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner)","\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions deals random cards. \"\"\" deck = list(range(52)) def","of the round. \"\"\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1","\" \" UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions deals random cards. \"\"\"","index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \"\"\"","return False, -1 \"\"\" This function counts the points in each hand. Note:","this Map \"weights\". And the array of length-52 represets the proportion with which","= np.array([i for i in range(suit * 13, (suit + 1) * 13)","theirs. \"\"\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards)","+= 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\" This function checks if the agent plays","+ 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0))","\"\"\" This function checks if the agent plays their highest card even though","cards_in_hand = set(0, 1, 4, 8, 11, 20, 24, 38) The agent choose","\" UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions deals random cards. \"\"\" deck","beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \"","play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) #","card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards","(determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the BridgeAgent weights. # If","8, 11, 20, 24, 38) The agent choose to play whichever remaining card","play a Diamond if it has Diamonds. In this example, agent will most","= (1, set(23, 0)), weights[state] will likely have very large values at indices","play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards = [i for i","self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent has higher cards, does","The agent is 3rd to play a card and must play a Diamond","win. \"\"\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3","25, 38, 51 \"\"\" def count_points(hands): points = [] for hand in hands:","if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the valid card with","partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1]","the right of the declarer starts the game NS_Wins = 0 # used","points in each hand # agent's partnership has more points and agent is","if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ):","shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None,","policy[count])) count += 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This","in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if i in hands[player_idx]])","player == 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the","False, -1 \"\"\" This function counts the points in each hand. Note: Ace","> 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1]","agent is not declarer and agent should start the play return False, -1","is 12, 25, 38, 51 \"\"\" def count_points(hands): points = [] for hand","2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins +=","max = np.argmax(y) policy.append(max) count += 1 game_file = \"Bridge_\" + str(game +","card has the highest weight. The agent must play a Diamond if it","14), then the agent loses. We want to decrease the proportion with which","suit == -1: return random.choice(cards_in_hand) valid_cards = [i for i in range(suit *","write out policy if ba and game == (NUM_GAMES_TRAIN - 1): policy =","each of the 52 cards given that it is at that state. In","4th card is not 25, then the agent wins. We want to incrase","# For each round for _ in range(13): cards_played = [] agent_card_played =","'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE SOME CONSTANTS","played highest card, does agent play lowest card? do they beat their partner?","weights[state] will likely have very large values at indices 24 and 25 since","of Diamonds. The agent is 3rd to play a card and must play","function plays 13 rounds of 1 NT bridge and outputs a winner. \"\"\"","\" PLAY A SINGLE GAME OF BRIDGE \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function plays","game, determine and write out policy if ba and game == (NUM_GAMES_TRAIN -","+ str(t) + \".csv\", 'w') as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\"","highest weight. The agent must play a Diamond if it has Diamonds. In","indices 24 and 25 since a Diamond 13 and Diamond 14 will beat","bridge and outputs a winner. \"\"\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards","it play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards)","\"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags()","24 has the highest weight. card_played = ba.play_card(state, cards_in_hand) \"\"\" def play_card(self, state,","= 0.9995 # 10,000 # self.alpha = 0.99995 # 100,000 self.alpha = 0.999995","0)), weights[state] will likely have very large values at indices 24 and 25","10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL AGENT \"","a Diamond 12 and Club 2 with an opening suit of Diamonds. The","2 -> Spade 14 Jack is 11 Queen is 12 King is 13","states_accessed): count = 0 with open(filename + \"_Last_Game.txt\", 'w') as g: g.write(\"Cards in","# Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the","4 if player_idx == 2: # Agent plays if ba: agent_state = State(opening_suit,","= np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 # self.alpha = 0.9995","determines the declarer based on partnership with the most points. Return: (agent_is_declarer, declarer_idx)","51 are Spade 2 -> Spade 14 Jack is 11 Queen is 12","card_partner in [-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]),","or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played","a Diamond if it has one. Representing the MDP with a Map from","25 since a Diamond 13 and Diamond 14 will beat the Diamond 12.","higher card than what's been played. \"\"\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played,","range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]: state = State( opening_suit,","9: p += 1 points.append(p) return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS PERFORMANCE OF","\"State\" where no cards have been played yet. Clubs is 0 Diamonds is","the proportion with which the agent should play each of the 52 cards","represets the proportion with which the agent should play each of the 52","Delta (want this to be positive): {average_win_delta}\") print(f\"Average Red Flag Ratios - Agent:","an opening suit of Diamonds. The agent is 3rd to play a card","the EXAMPLE: # suit = 1 suit = state.opening_suit # valid_cards = [20,","1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\" This function checks for any red flags based","card) # 3 cards played and agent has higher cards, does it play","which beats 23 <-- hopefully 24 has the highest weight. card_played = ba.play_card(state,","# 3 cards played + partner has played highest card, does agent play","card else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track","f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative statistics on red flags for","hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner)","card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\" This function checks","\"\"\" This function checks for any red flags based on what the agent","card > max_val: max_val, max_idx = card, idx return max_idx \"\"\" This function","random cards. \"\"\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39],","suit == -1: return # highest card played so far is higher than","= np.array([i for i in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i","card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards)","UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions deals random cards. \"\"\" deck =","0: valid_cards = cards_in_hand # Choose the valid card with highest weight. #","38 are Heart 2 -> Heart 14 Cards 39 -> 51 are Spade","the MDP with a Map from a \"State\" to an array of length-52:","= 1 suit = state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i","for i in range(suit * 13, (suit + 1) * 13) if i","state. In this example, with state = (1, set(23, 0)), weights[state] will likely","3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in","used to count total wins in agent partnership states_accessed = [] # records","a card in order starting from round_winner for player in range(4): card =","of the declarer starts the game NS_Wins = 0 # used to count","* self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) card_played =","played already and the agent has at least one higher card than what's","for opening_suit in range(4): for card_1 in range(52): for card_2 in range(card_1, 52):","game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" +","card in hand: if card % 13 == 12: p += 4 elif","on partnership with the most points. Return: (agent_is_declarer, declarer_idx) \"\"\" def agent_declarer(hands): points","1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\" This","count = 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y)","non-agents who play randomly. \"\"\" def play_random_card(suit, cards_in_hand): if suit == -1: return","been updated for this game # For each round for _ in range(13):","in order starting from round_winner for player in range(4): card = None player_idx","hands[3] = West's cards \"\"\" round_winner = (d + 1) % 4 #","on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta =","np.array([i for i in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for","else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot plays","cards played + partner has played highest card, does agent play lowest card?","Red Flag Ratios - Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" + str(t) +","\"\"\" import copy import datetime import numpy as np import random from collections","count total wins in agent partnership states_accessed = [] # records which states","assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit","in self.weights: f.write(\"State: suit {} | cards played {} | partner's card {}\\nBest","13 == 11: p += 3 elif card % 13 == 10: p","f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative statistics on red flags","and points[2] > points[0]: return True, 2 # agent is not declarer and","already and the agent has at least one higher card than what's been","if suit * 13 <= card < (suit + 1) * 13 and","state = State(1, frozenset(23, 0)) We have a Diamond 12 and Club 2","25 are Diamond 2 -> Diamond 14 Cards 26 -> 38 are Heart","1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative","starting from round_winner for player in range(4): card = None player_idx = (round_winner","length-52 represets the proportion with which the agent should play each of the","agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] =","% STATS_PER == 0: print(f\"{game + 1} / \", end=\"\", flush=True) rfv =","plays 13 rounds of 1 NT bridge and outputs a winner. \"\"\" def","# Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\" This function","determine and write out policy if ba and game == (NUM_GAMES_TRAIN - 1):","[] # records which states have been updated for this game # For","This function determines the winner of the round. \"\"\" def determine_round_winner(suit, cards_played): max_idx","if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state,","Representing a \"Card\" as an integer: Cards 0 -> 12 are Club 2","is 1 Hearts is 2 Spades is 3 Representing a \"State\" as an","array of length-52 represets the proportion with which the agent should play each","a Diamond 13 and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State","have very large values at indices 24 and 25 since a Diamond 13","the end of the data training phase. \"\"\" def write_policy(self, cards_in_hand, policy, filename,","def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer,","the BridgeAgent weights. # If the BridgeAgent or N wins. if round_winner ==","len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the valid card with highest","If the BridgeAgent or N wins. if round_winner == 0 or round_winner ==","card has an equal chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(),","+= 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1])","+ \".csv\", 'w') as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\")","< (suit + 1) * 13 and card > max_val: max_val, max_idx =","= State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit,","+= 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions deals","is guaranteed to win. \"\"\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if","states_accessed = [] # records which states have been updated for this game","valid_cards = [i for i in range(suit * 13, (suit + 1) *","the proportion with which we play 24. ba.add_win(state, card_played) \"\"\" def add_win(self, state,","1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\" This","filename, states_accessed): count = 0 with open(filename + \"_Last_Game.txt\", 'w') as g: g.write(\"Cards","= [] count = 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max","declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card,","choose to play whichever remaining card has the highest weight. The agent must","1 \"\"\" This function checks if the agent plays a higher card even","4 # the person to the right of the declarer starts the game","ba.play_card(state, cards_in_hand) \"\"\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit","who play randomly. \"\"\" def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand)","card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot plays card","ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and","any red flags based on what the agent played. \"\"\" def assess_card_played(self, hands,","agent_card_played = [-1, -1] agent_state = None agent_state_2 = None opening_suit = -1","0)) We have a Diamond 12 and Club 2 with an opening suit","\"\"\" This function determines the declarer based on partnership with the most points.","11 Queen is 12 King is 13 Ace is 14 Representing a \"Suit\"","\"\"\" This function is used by non-agents who play randomly. \"\"\" def play_random_card(suit,","NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative statistics on red","<-- hopefully 24 has the highest weight. card_played = ba.play_card(state, cards_in_hand) \"\"\" def","% 4 # the person to the right of the declarer starts the","agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and train:","len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] +=","> points[0]: return True, 2 # agent is not declarer and agent should","Spades is 3 Representing a \"State\" as an opening suit and frozenset of","it has one. Representing the MDP with a Map from a \"State\" to","the agent played. \"\"\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards","the agent wins a round when there's three cards played already and the","policy if ba and game == (NUM_GAMES_TRAIN - 1): policy = [] count","played and agent has higher cards, does it play highest card or highest","\".csv\", 'w') as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf","= ba.play_card(state, cards_in_hand) \"\"\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE: #","agent_valid_cards, card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY A SINGLE GAME OF BRIDGE","\"\"\" def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards = [i","== -1: return # highest card played so far is higher than agent's","- 1): policy = [] count = 0 for x in ba.weights: y","SOME CONSTANTS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52 # Agent can choose any card","is used by non-agents who play randomly. \"\"\" def play_random_card(suit, cards_in_hand): if suit","main(): start_time = datetime.datetime.now() hands = [] # TRAINING print(f\"TRAINING on {NUM_GAMES_TRAIN} games\")","set(23, 0)) # Diamond 12, Club 2 <-- first 2 cards in round","their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY A SINGLE","0: print(f\"{game + 1} / \", end=\"\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random =","0 # used to count total wins in agent partnership states_accessed = []","3rd card in round If 4th card is not 25, then the agent","[i for i in range(suit * 13, (suit + 1) * 13) if","if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\" This function determines the","valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \"","self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\" This function checks if the agent wins a round","self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\" This function checks for any red flags based on","random from collections import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \"Card\" as","24, which beats 23 <-- hopefully 24 has the highest weight. card_played =","copy.copy(hands[2]) declarer, d = agent_declarer(hands) \"\"\" hands[0] = North's cards hands[1] = East's","in enumerate(cards_played): if suit * 13 <= card < (suit + 1) *","total wins in agent partnership states_accessed = [] # records which states have","such that every card has an equal chance of being chosen. self.weights =","12, Club 2 <-- first 2 cards in round card_played = 24 #","card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY A SINGLE GAME OF BRIDGE \"","hands[0] = North's cards hands[1] = East's cards hands[2] = Agent's cards hands[3]","and outputs a winner. \"\"\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards =","- NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\" f\"{rfv[2]},{rftc[2]},\" f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative statistics on","\"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This functions deals random cards.","Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE","{}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\"State:","* 13) if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand","\"Suit\" as an integer: n/a is -1 <-- used in a \"State\" where","(d + 1) % 4 # the person to the right of the","policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\"","2 with an opening suit of Diamonds. The agent is 3rd to play","max = np.argmax(y) while max in x.cards_played: y[max] = -1 max = np.argmax(y)","+ str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t,","used by non-agents who play randomly. \"\"\" def play_random_card(suit, cards_in_hand): if suit ==","card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\" This function checks","hands[player_idx]) # Keep track of the opening suit. if player == 0: opening_suit","\"_Game_Data_Avg_Train-\" + str(t) + \".csv\", 'w') as m: m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def","proportion with which we play 24. ba.add_loss(state, card_played) \"\"\" def add_loss(self, state, card_played):","Queen is 12 King is 13 Ace is 14 Representing a \"Suit\" as","hands[1] = East's cards hands[2] = Agent's cards hands[3] = West's cards \"\"\"","\"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS PERFORMANCE OF BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def","STATS_PER = 1000 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def","PERFORMANCE OF BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3)","1) * 13 and card > max_val: max_val, max_idx = card, idx return","'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" NUM_ACTIONS = 52 # Agent can choose any card to play (only","self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 # self.alpha =","agent_declarer(hands): points = count_points(hands) # determines the number of points in each hand","= (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random","Cumulative statistics on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0)","0: return random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\" This function determines the winner of the","# self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \"\"\" EXAMPLE state =","+= play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num","i in hands[player_idx]]) if suit == -1: return # highest card played so","end_time = datetime.datetime.now() print(\"Runtime: \", end_time - start_time) # runtime if __name__ ==","max_idx \"\"\" This function determines the declarer based on partnership with the most","\"State\" as an opening suit and frozenset of up to 3 \"Card\"-s: state","'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function plays 13 rounds of 1 NT bridge and outputs","the last game, determine and write out policy if ba and game ==","if the agent plays their highest card even though the highest card already","agent played. \"\"\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards =","card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1)","ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last","in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards","[-1, -1] agent_state = None agent_state_2 = None opening_suit = -1 # Each","likely play 24, which beats 23 <-- hopefully 24 has the highest weight.","10: p += 2 elif card % 13 == 9: p += 1","hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game + 1) % STATS_PER ==","(suit + 1) * 13 and card > max_val: max_val, max_idx = card,","2: # Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card","= np.argmax(y) policy.append(max) count += 1 game_file = \"Bridge_\" + str(game + 1)","12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" DEFINE SOME","return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \"\"\" This function is used by non-agents who","card with highest weight. # index_into_valid_counts = 1 since 20 has a smaller","== 3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] +=","+= 3 elif card % 13 == 10: p += 2 elif card","opening suit. if player == 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card)","agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card =","is 25 (Diamond 14), then the agent loses. We want to decrease the","23 <-- hopefully 24 has the highest weight. card_played = ba.play_card(state, cards_in_hand) \"\"\"","plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit. if","a \"Suit\" as an integer: n/a is -1 <-- used in a \"State\"","integer: n/a is -1 <-- used in a \"State\" where no cards have","ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game","states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t)","highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0]","= \"Bridge_\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def","str(t) + \".csv\", 'w') as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\" \"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\"","+ player) % 4 if player_idx == 2: # Agent plays if ba:","will likely have very large values at indices 24 and 25 since a","1) % STATS_PER == 0: print(f\"{game + 1} / \", end=\"\", flush=True) rfv","24. ba.add_loss(state, card_played) \"\"\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1","np.argmax(y) policy.append(max) count += 1 game_file = \"Bridge_\" + str(game + 1) ba.write_policy(agents_cards,","iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\"Runtime: \", end_time - start_time) # runtime if __name__","= West's cards \"\"\" round_winner = (d + 1) % 4 # the","function checks if the agent plays a higher card even though their partner","self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY A SINGLE GAME OF","In this example, with state = (1, set(23, 0)), weights[state] will likely have","ba.add_win(state, card_played) \"\"\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 *","= copy.copy(hands[2]) declarer, d = agent_declarer(hands) \"\"\" hands[0] = North's cards hands[1] =","for _ in range(13): cards_played = [] agent_card_played = [-1, -1] agent_state =","of points in each hand # agent's partnership has more points and agent","is 13 Ace is 14 Representing a \"Suit\" as an integer: n/a is","# If the BridgeAgent or N wins. if round_winner == 0 or round_winner","West's cards \"\"\" round_winner = (d + 1) % 4 # the person","card even though their partner is guaranteed to win. \"\"\" def partner_win(self, valid_cards,","of the 52 cards given that it is at that state. In this","t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Train-\" + str(t) + \".csv\", 'w') as k:","Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename + \".txt\", 'w') as f: for state in self.weights:","0.9999995 # 5,000,000 self.game_num = 1 \"\"\" EXAMPLE state = State(1, set(23, 0))","average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta (want this","if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \"\"\" This function","the round. \"\"\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for","0)) card_played = 24 If 4th card is 25 (Diamond 14), then the","= North's cards hands[1] = East's cards hands[2] = Agent's cards hands[3] =","\"\"\" CS 238 Final Project: Bridge RL Agent <NAME> & <NAME> \"\"\" import","if (game + 1) % STATS_PER == 0: print(f\"{game + 1} / \",","card to play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000","card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0]","<NAME> \"\"\" import copy import datetime import numpy as np import random from","there's three cards played already and the agent has at least one higher","= [] for hand in hands: p = 0 for card in hand:","card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards)","played {} | partner's card {}\\nBest Card To Play: {}\\n\\n\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count]))","True, 2 # agent is not declarer and agent should start the play","in range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]: state = State(","# for the last game, determine and write out policy if ba and","cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\" This function determines","used in a \"State\" where no cards have been played yet. Clubs is","East's cards hands[2] = Agent's cards hands[3] = West's cards \"\"\" round_winner =","1 points.append(p) return points \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" TRACKS PERFORMANCE OF BRIDGE AGENT \"","deck[13:26], deck[26:39], deck[39:52]] \"\"\" This function is used by non-agents who play randomly.","clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\" This function checks if the","state in states_accessed: g.write(\"State: suit {} | cards played {} | partner's card","g.write(\"State: suit {} | cards played {} | partner's card {}\\nBest Card To","and game == (NUM_GAMES_TRAIN - 1): policy = [] count = 0 for","1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win","North's cards hands[1] = East's cards hands[2] = Agent's cards hands[3] = West's","deck[39:52]] \"\"\" This function is used by non-agents who play randomly. \"\"\" def","self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \"\"\" This function write the","< max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\" This function checks if","barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game in range(iterations):","+ \"_Game_Data_Train-\" + str(t) + \".csv\", 'w') as k: k.write(\"game,\" \"agent_wins,random_wins,diff_wins,\" \"agent_rfv_a,agent_rftc_a,\" \"agent_rfv_b,agent_rftc_b,\"","winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the","= -1 max_val = -1 for idx, card in enumerate(cards_played): if suit *","TRACKS PERFORMANCE OF BRIDGE AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS =","card_played) \"\"\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha","and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands,","= set(0, 1, 4, 8, 11, 20, 24, 38) The agent choose to","no cards have been played yet. Clubs is 0 Diamonds is 1 Hearts","= copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max] = -1 max","has an equal chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)]","in range(card_1, 52): for card_3 in range(card_2, 52): for card_partner in [-1, card_1,","self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0, 1, 4,","all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if","NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game + 1)","weight. The agent must play a Diamond if it has Diamonds. In this","random.choice(valid_cards) \"\"\" This function determines the winner of the round. \"\"\" def determine_round_winner(suit,","+ 1) * 13)) valid_cards = np.array([i for i in all_valid_cards if i","\"\"\" def count_points(hands): points = [] for hand in hands: p = 0","-> Heart 14 Cards 39 -> 51 are Spade 2 -> Spade 14","1 Hearts is 2 Spades is 3 Representing a \"State\" as an opening","0: # if agent is declarer, they play their partner's cards if ba","== 11: p += 3 elif card % 13 == 10: p +=","% 13 == 11: p += 3 elif card % 13 == 10:","\"State\" to an array of length-52: We call this Map \"weights\". And the","if i in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if i","/ ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS,","= State(1, set(23, 0)) card_played = 24 If 4th card is 25 (Diamond","agent_state_2 = None opening_suit = -1 # Each player plays a card in","the person to the right of the declarer starts the game NS_Wins =","in each hand # agent's partnership has more points and agent is declarer","agent_declarer(hands) \"\"\" hands[0] = North's cards hands[1] = East's cards hands[2] = Agent's","= ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit,","= BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game in range(iterations): hands","in a \"State\" where no cards have been played yet. Clubs is 0","been played yet. Clubs is 0 Diamonds is 1 Hearts is 2 Spades","and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if","example, agent will most likely play 24, which beats 23 <-- hopefully 24","Cards 26 -> 38 are Heart 2 -> Heart 14 Cards 39 ->","plays a higher card even though their partner is guaranteed to win. \"\"\"","return random.choice(valid_cards) \"\"\" This function determines the winner of the round. \"\"\" def","as np import random from collections import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing","True) # TESTING -- we don't change the weights here print(f\"TESTING on {NUM_GAMES_TEST}","average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\"Average Win Delta (want this to be positive): {average_win_delta}\")","ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if","0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \"\"\"","cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card =","their partner's cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2)","Heart 14 Cards 39 -> 51 are Spade 2 -> Spade 14 Jack","hands[2] = Agent's cards hands[3] = West's cards \"\"\" round_winner = (d +","Final Project: Bridge RL Agent <NAME> & <NAME> \"\"\" import copy import datetime","Diamonds. In this example, agent will most likely play 24, which beats 23","least one higher card than what's been played. \"\"\" def higher_card(self, valid_cards, agent_valid_cards,","and Club 2 with an opening suit of Diamonds. The agent is 3rd","card_played = ba.play_card(state, cards_in_hand) \"\"\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE:","\"Card\"-s: state = State(1, frozenset(23, 0)) We have a Diamond 12 and Club","and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2]","ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit,","cards have been played yet. Clubs is 0 Diamonds is 1 Hearts is","= [i for i in range(suit * 13, (suit + 1) * 13)","frozenset(23, 0)) We have a Diamond 12 and Club 2 with an opening","np.array([i for i in all_valid_cards if i in hands[player_idx]]) if suit == -1:","hopefully 24 has the highest weight. card_played = ba.play_card(state, cards_in_hand) \"\"\" def play_card(self,","are Diamond 2 -> Diamond 14 Cards 26 -> 38 are Heart 2","agent_valid_cards, card) # 3 cards played and agent has higher cards, does it","2 elif card % 13 == 9: p += 1 points.append(p) return points","12: p += 4 elif card % 13 == 11: p += 3","random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\" This function determines the winner of the round. \"\"\"","# Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card =","play 24, which beats 23 <-- hopefully 24 has the highest weight. card_played","a round when there's three cards played already and the agent has at","up to 3 \"Card\"-s: state = State(1, frozenset(23, 0)) We have a Diamond","[0] NS_Wins_random = [0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] +=","equal chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS,","-> 51 are Spade 2 -> Spade 14 Jack is 11 Queen is","player_idx, partners_cards) elif player_idx == 0: # if agent is declarer, they play","== 0: valid_cards = cards_in_hand # Choose the valid card with highest weight.","2 -> Diamond 14 Cards 26 -> 38 are Heart 2 -> Heart","= 24 If 4th card is 25 (Diamond 14), then the agent loses.","-1] agent_state = None agent_state_2 = None opening_suit = -1 # Each player","g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename + \".txt\", 'w') as f: for state","= State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played,","plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx])","train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba","== 0: # if agent is declarer, they play their partner's cards if","\"\"\" EXAMPLE state = State(1, set(23, 0)) # Diamond 12, Club 2 <--","i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \"\"\" This","smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max()))","+= 1 \"\"\" This function checks if the agent wins a round when","while max in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count +=","opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else:","randomly. \"\"\" def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards =","the agent has at least one higher card than what's been played. \"\"\"","in range(13): cards_played = [] agent_card_played = [-1, -1] agent_state = None agent_state_2","Diamond 12, Club 2 <-- first 2 cards in round card_played = 24","state.partners_card, policy[count])) count += 1 \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" UTILITY FUNCTIONS \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\"","with an opening suit of Diamonds. The agent is 3rd to play a","52 # Agent can choose any card to play (only some are valid).","set(0, 1, 4, 8, 11, 20, 24, 38) The agent choose to play","state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\"State: suit {} | cards played","for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins)","card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the BridgeAgent","state = State(1, set(23, 0)) # Diamond 12, Club 2 <-- first 2","flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) /","self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played + partner has played","\"agent_rfv_c,agent_rftc_c,\" \"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0]","MDP with a Map from a \"State\" to an array of length-52: We","f\"{rfv_random[0]},{rftc_random[0]},\" f\"{rfv_random[1]},{rftc_random[1]},\" f\"{rfv_random[2]},{rftc_random[2]},\" f\"\\n\") # Cumulative statistics on red flags for every STATS_PER","if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and","played. \"\"\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit","and the agent has at least one higher card than what's been played.","card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card","print(f\"{game + 1} / \", end=\"\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS","points[3] and points[2] > points[0]: return True, 2 # agent is not declarer","20, 24, 38) The agent choose to play whichever remaining card has the","must play a Diamond if it has one. Representing the MDP with a","as an opening suit and frozenset of up to 3 \"Card\"-s: state =","= np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\"","end=\"\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random =","a higher card even though their partner is guaranteed to win. \"\"\" def","Adjust the BridgeAgent weights. # If the BridgeAgent or N wins. if round_winner","a Diamond if it has Diamonds. In this example, agent will most likely","self.alpha = 0.997 # 1,000 # self.alpha = 0.9995 # 10,000 # self.alpha","Ratios - Agent: {average_rf_ratios_agent}\") print(f\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN)","valid_cards = np.array([i for i in range(suit * 13, (suit + 1) *","round_winner) % 4 # Adjust the BridgeAgent weights. # If the BridgeAgent or","an integer: Cards 0 -> 12 are Club 2 -> Club 14 Cards","State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx])","1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN)","points[0] + points[2] > points[1] + points[3] and points[2] > points[0]: return True,","self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \"\"\" This function checks if the agent","ba def main(): start_time = datetime.datetime.now() hands = [] # TRAINING print(f\"TRAINING on","game # For each round for _ in range(13): cards_played = [] agent_card_played","\"_Last_Game.txt\", 'w') as g: g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename + \".txt\", 'w')","and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card ==","f.write(\"State: suit {} | cards played {} | partner's card {}\\nBest Card To","to 3 \"Card\"-s: state = State(1, frozenset(23, 0)) We have a Diamond 12","Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State', ['opening_suit', 'cards_played',","f\"\\n\") # Cumulative statistics on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags()","index_into_valid_counts = 1 since 20 has a smaller weight than 24. # index_into_valid_cards","0)) cards_in_hand = set(0, 1, 4, 8, 11, 20, 24, 38) The agent","/= (1 + 0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1,","and agent is declarer if points[0] + points[2] > points[1] + points[3] and","import numpy as np import random from collections import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF","# self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha","card already played is higher than theirs. \"\"\" def highest_card(self, valid_cards, agent_valid_cards, card):","idx, card in enumerate(cards_played): if suit * 13 <= card < (suit +","def count_points(hands): points = [] for hand in hands: p = 0 for","the agent should play each of the 52 cards given that it is","of 1 NT bridge and outputs a winner. \"\"\" def play_game(game, hands, train=False,","14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card'])","state = State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11, 20,","states_accessed: g.write(\"State: suit {} | cards played {} | partner's card {}\\nBest Card","self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT =","games\") ba = BridgeAgent() ba = game_summary(ba, True) # TESTING -- we don't","has one. Representing the MDP with a Map from a \"State\" to an","all_valid_cards = list(range(suit * 13, (suit + 1) * 13)) valid_cards = np.array([i","records which states have been updated for this game # For each round","1, 4, 8, 11, 20, 24, 38) The agent choose to play whichever","3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1","does agent play lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card,","with open(filename + \"_Last_Game.txt\", 'w') as g: g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename","array of length-52: We call this Map \"weights\". And the array of length-52","We want to decrease the proportion with which we play 24. ba.add_loss(state, card_played)","+= 1 game_file = \"Bridge_\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed)","print(f\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\") print(f\"Average Red Flag Ratios - Random:","collections import namedtuple \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \"Card\" as an integer:","agent_valid_cards = np.array([i for i in all_valid_cards if i in hands[player_idx]]) if suit","0.1 * self.alpha ** self.game_num) \"\"\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand","<-- first 2 cards in round card_played = 24 # Diamond 13 <--","x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played:","of length-52 represets the proportion with which the agent should play each of","cards, does it play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card,","frozenset of up to 3 \"Card\"-s: state = State(1, frozenset(23, 0)) We have","most likely play 24, which beats 23 <-- hopefully 24 has the highest","= play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif","def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\" This function checks if","wins a round when there's three cards played already and the agent has","= [20, 24] valid_cards = np.array([i for i in range(suit * 13, (suit","\"random_rfv_a,random_rftc_a,\" \"random_rfv_b,random_rftc_b,\" \"random_rfv_c,random_rftc_c\\n\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random","print(f\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\") with open(str(NUM_GAMES_TRAIN) + \"_Game_Data_Avg_Train-\" + str(t)","def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num)","\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" \"\"\" This function plays 13 rounds of 1 NT bridge and","policy = [] count = 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x])","str(t) + \".csv\", 'a') as k: k.write( f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\"","for idx, card in enumerate(cards_played): if suit * 13 <= card < (suit","m.write(f\"avg_win_delta,avg_rf_agent,avg_rf_random\\n\" f\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\n\") return ba def main(): start_time = datetime.datetime.now() hands = [] #","in Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename + \".txt\", 'w') as f: for state in","we play 24. ba.add_loss(state, card_played) \"\"\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1","valid_cards = [20, 24] valid_cards = np.array([i for i in range(suit * 13,","* 13 and card > max_val: max_val, max_idx = card, idx return max_idx","game NS_Wins = 0 # used to count total wins in agent partnership","agent_valid_cards, card, cards_played, partners_cards) # 3 cards played + partner has played highest","f: for state in self.weights: f.write(\"State: suit {} | cards played {} |","'w') as g: g.write(\"Cards in Hand: {}\\n\\n\".format(cards_in_hand)) with open(filename + \".txt\", 'w') as","\"\"\" def agent_declarer(hands): points = count_points(hands) # determines the number of points in","ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else:","import copy import datetime import numpy as np import random from collections import","== self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \"\"\" This function write","to decrease the proportion with which we play 24. ba.add_loss(state, card_played) \"\"\" def","card played so far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card)","and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards","(len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards)","is 11 Queen is 12 King is 13 Ace is 14 Representing a","if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose","> max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \"\"\" This function checks for","= (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the BridgeAgent weights. #","max_val = -1 for idx, card in enumerate(cards_played): if suit * 13 <=","RL AGENT \" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgent: def __init__(self): # We initialize all weights","play lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards)","hands[player_idx]]) if suit == -1: return # highest card played so far is","State(1, set(23, 0)) card_played = 24 If 4th card is 25 (Diamond 14),","to win. \"\"\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) ==","random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \"\"\" This function is used by non-agents","since 20 has a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards","a \"State\" to an array of length-52: We call this Map \"weights\". And","EXAMPLE: # suit = 1 suit = state.opening_suit # valid_cards = [20, 24]","has higher cards, does it play highest card or highest necessary card? self.higher_card(valid_cards,","3 \"Card\"-s: state = State(1, frozenset(23, 0)) We have a Diamond 12 and","cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename + \"_Last_Game.txt\", 'w') as","13, (suit + 1) * 13)) valid_cards = np.array([i for i in all_valid_cards","Diamond if it has Diamonds. In this example, agent will most likely play","i in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the","1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] +=","= barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN)","cards_played, partners_cards) # 3 cards played + partner has played highest card, does","= 1 \"\"\" EXAMPLE state = State(1, set(23, 0)) # Diamond 12, Club","an array of length-52: We call this Map \"weights\". And the array of","\".csv\", 'a') as k: k.write( f\"{game + 1},\" f\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\" f\"{rfv[0]},{rftc[0]},\" f\"{rfv[1]},{rftc[1]},\"","Diamond 2 -> Diamond 14 Cards 26 -> 38 are Heart 2 ->","'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\"\"\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS =","each hand. Note: Ace is 12, 25, 38, 51 \"\"\" def count_points(hands): points","\", end=\"\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random","# valid_cards = [20, 24] valid_cards = np.array([i for i in range(suit *","to play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER","13 and card > max_val: max_val, max_idx = card, idx return max_idx \"\"\"","card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 #","list(range(suit * 13, (suit + 1) * 13)) valid_cards = np.array([i for i","if it has Diamonds. In this example, agent will most likely play 24,","card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit,","is -1 <-- used in a \"State\" where no cards have been played","% 4 # Adjust the BridgeAgent weights. # If the BridgeAgent or N","self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \"\"\" This function checks if the agent plays their highest","\"\"\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) >","they play their partner's cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played),","Agent's cards hands[3] = West's cards \"\"\" round_winner = (d + 1) %","\"\"\" This function counts the points in each hand. Note: Ace is 12,","= State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11, 20, 24,","(only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000","partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1) * 13)) valid_cards =","14 Cards 13 -> 25 are Diamond 2 -> Diamond 14 Cards 26","hand: if card % 13 == 12: p += 4 elif card %","partnership has more points and agent is declarer if points[0] + points[2] >","+ 1) % 4 # the person to the right of the declarer","# if agent is declarer, they play their partner's cards if ba and","State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx,","card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 # self.alpha"],"string":"[\n \"0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card.\",\n \"they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY\",\n \"== 12: p += 4 elif card % 13 == 11: p +=\",\n \"'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52\",\n \"checks if the agent plays a higher card even though their partner is\",\n \"+ \\\"_Game_Data_Avg_Train-\\\" + str(t) + \\\".csv\\\", 'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba\",\n \"AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3)\",\n \"datetime.datetime.now() print(\\\"Runtime: \\\", end_time - start_time) # runtime if __name__ == \\\"__main__\\\": main()\",\n \"cards hands[1] = East's cards hands[2] = Agent's cards hands[3] = West's cards\",\n \"to 1 such that every card has an equal chance of being chosen.\",\n \"the highest card already played is higher than theirs. \\\"\\\"\\\" def highest_card(self, valid_cards,\",\n \"are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\"\",\n \"-1: return # highest card played so far is higher than agent's highest\",\n \"ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx])\",\n \"1): policy = [] count = 0 for x in ba.weights: y =\",\n \"and 25 since a Diamond 13 and Diamond 14 will beat the Diamond\",\n \"for the last game, determine and write out policy if ba and game\",\n \"f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\")\",\n \"agent is declarer if points[0] + points[2] > points[1] + points[3] and points[2]\",\n \"self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1\",\n \"in range(4): card = None player_idx = (round_winner + player) % 4 if\",\n \"# We initialize all weights to 1 such that every card has an\",\n \"np.argmax(y) while max in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count\",\n \"count_points(hands): points = [] for hand in hands: p = 0 for card\",\n \"+ 1) * 13) if i in cards_in_hand] if len(valid_cards) == 0: return\",\n \"states have been updated for this game # For each round for _\",\n \"+ 1} / \\\", end=\\\"\\\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc\",\n \"k.write( f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\"\",\n \"Ace is 12, 25, 38, 51 \\\"\\\"\\\" def count_points(hands): points = [] for\",\n \"(suit + 1) * 13)) valid_cards = np.array([i for i in all_valid_cards if\",\n \"as an integer: Cards 0 -> 12 are Club 2 -> Club 14\",\n \"wins. We want to incrase the proportion with which we play 24. ba.add_win(state,\",\n \"2 # agent is not declarer and agent should start the play return\",\n \"# 3 cards played and agent has higher cards, does it play highest\",\n \"round If 4th card is not 25, then the agent wins. We want\",\n \"1 \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) # Diamond 12, Club 2\",\n \"= np.zeros(3) \\\"\\\"\\\" This function checks if the agent plays their highest card\",\n \"# TESTING -- we don't change the weights here print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\")\",\n \"from collections import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \\\"Card\\\" as an\",\n \"\\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52 # Agent\",\n \"values at indices 24 and 25 since a Diamond 13 and Diamond 14\",\n \"== max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\" This function checks if\",\n \"\\\"\\\"\\\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for idx, card\",\n \"have been updated for this game # For each round for _ in\",\n \"example, with state = (1, set(23, 0)), weights[state] will likely have very large\",\n \"p = 0 for card in hand: if card % 13 == 12:\",\n \"if ba and game == (NUM_GAMES_TRAIN - 1): policy = [] count =\",\n \"max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card >\",\n \"cards in round card_played = 24 # Diamond 13 <-- 3rd card in\",\n \"Diamond 12 and Club 2 with an opening suit of Diamonds. The agent\",\n \"three cards played already and the agent has at least one higher card\",\n \"hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1\",\n \"game == (NUM_GAMES_TRAIN - 1): policy = [] count = 0 for x\",\n \"card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\" This function checks\",\n \"-> 25 are Diamond 2 -> Diamond 14 Cards 26 -> 38 are\",\n \"5,000,000 self.game_num = 1 \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) # Diamond\",\n \"guaranteed to win. \\\"\\\"\\\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played)\",\n \"{average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" + str(t) + \\\".csv\\\", 'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\"\",\n \"rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with\",\n \"frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0]\",\n \"Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY FUNCTIONS\",\n \"highest card, does agent play lowest card? do they beat their partner? self.partner_win(valid_cards,\",\n \"agent_card_played[1]) # for the last game, determine and write out policy if ba\",\n \"at the end of the data training phase. \\\"\\\"\\\" def write_policy(self, cards_in_hand, policy,\",\n \"(1, set(23, 0)), weights[state] will likely have very large values at indices 24\",\n \"large values at indices 24 and 25 since a Diamond 13 and Diamond\",\n \"np.array([i for i in range(suit * 13, (suit + 1) * 13) if\",\n \"Club 2 with an opening suit of Diamonds. The agent is 3rd to\",\n \"None agent_state_2 = None opening_suit = -1 # Each player plays a card\",\n \"self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state =\",\n \"the valid card with highest weight. # index_into_valid_counts = 1 since 20 has\",\n \"this to be positive): {average_win_delta}\\\") print(f\\\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average\",\n \"as f: for state in self.weights: f.write(\\\"State: suit {} | cards played {}\",\n \"points[2] > points[1] + points[3] and points[2] > points[0]: return True, 2 #\",\n \"card, cards_played, partners_cards) # 3 cards played + partner has played highest card,\",\n \"card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS,\",\n \"13, (suit + 1) * 13) if i in cards_in_hand]) if len(valid_cards) ==\",\n \"24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1]\",\n \"13 rounds of 1 NT bridge and outputs a winner. \\\"\\\"\\\" def play_game(game,\",\n \"every card has an equal chance of being chosen. self.weights = {} self.weights[State(-1,\",\n \"13, (suit + 1) * 13) if i in cards_in_hand] if len(valid_cards) ==\",\n \"if i in hands[player_idx]]) if suit == -1: return # highest card played\",\n \"declarer_idx) \\\"\\\"\\\" def agent_declarer(hands): points = count_points(hands) # determines the number of points\",\n \"barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: # if agent\",\n \"== 0: print(f\\\"{game + 1} / \\\", end=\\\"\\\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random\",\n \"NT bridge and outputs a winner. \\\"\\\"\\\" def play_game(game, hands, train=False, ba=None, barf=None):\",\n \"1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card\",\n \"\\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) card_played = 24 If 4th card\",\n \"start_time = datetime.datetime.now() hands = [] # TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\") ba\",\n \"higher cards, does it play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards,\",\n \"so far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3\",\n \"= 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while\",\n \"is 3 Representing a \\\"State\\\" as an opening suit and frozenset of up\",\n \"round for _ in range(13): cards_played = [] agent_card_played = [-1, -1] agent_state\",\n \"with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" + str(t) + \\\".csv\\\", 'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\")\",\n \"3rd to play a card and must play a Diamond if it has\",\n \"cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) %\",\n \"{} | partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count\",\n \"end of the data training phase. \\\"\\\"\\\" def write_policy(self, cards_in_hand, policy, filename, states_accessed):\",\n \"ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx])\",\n \"cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards = [i for i in\",\n \"agent partnership states_accessed = [] # records which states have been updated for\",\n \"index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24\",\n \"OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function plays 13 rounds of 1 NT\",\n \"every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) -\",\n \"is 0 Diamonds is 1 Hearts is 2 Spades is 3 Representing a\",\n \"<-- used in a \\\"State\\\" where no cards have been played yet. Clubs\",\n \"self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995 # 100,000 self.alpha =\",\n \"in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards):\",\n \"STATS_PER == 0: print(f\\\"{game + 1} / \\\", end=\\\"\\\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS\",\n \"= 0.9999995 # 5,000,000 self.game_num = 1 \\\"\\\"\\\" EXAMPLE state = State(1, set(23,\",\n \"\\\"\\\"\\\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit = 1\",\n \"the number of points in each hand # agent's partnership has more points\",\n \"+ str(t) + \\\".csv\\\", 'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def main():\",\n \"(round_winner + player) % 4 if player_idx == 2: # Agent plays if\",\n \"\\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY A SINGLE GAME OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This\",\n \"self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1\",\n \"0.9995 # 10,000 # self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 #\",\n \"= datetime.datetime.now() hands = [] # TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\") ba =\",\n \"+ 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") #\",\n \"the proportion with which we play 24. ba.add_loss(state, card_played) \\\"\\\"\\\" def add_loss(self, state,\",\n \"game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf)\",\n \"agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and write\",\n \"state.partners_card, policy[count])) if state in states_accessed: g.write(\\\"State: suit {} | cards played {}\",\n \"+= 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\" This function checks for any red flags\",\n \"even though their partner is guaranteed to win. \\\"\\\"\\\" def partner_win(self, valid_cards, agent_valid_cards,\",\n \"be positive): {average_win_delta}\\\") print(f\\\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag\",\n \"= card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: #\",\n \"points. Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\" def agent_declarer(hands): points = count_points(hands) # determines the\",\n \"is at that state. In this example, with state = (1, set(23, 0)),\",\n \"20 has a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards =\",\n \"13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) +\",\n \"barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for\",\n \"np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) #\",\n \"ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card\",\n \"The agent choose to play whichever remaining card has the highest weight. The\",\n \"def play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit = 1 suit\",\n \"if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the\",\n \"game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\\\"Runtime: \\\", end_time - start_time) # runtime\",\n \"in range(suit * 13, (suit + 1) * 13) if i in cards_in_hand]\",\n \"def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards)\",\n \"[] agent_card_played = [-1, -1] agent_state = None agent_state_2 = None opening_suit =\",\n \"{NUM_GAMES_TRAIN} games\\\") ba = BridgeAgent() ba = game_summary(ba, True) # TESTING -- we\",\n \"str(t) + \\\".csv\\\", 'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def main(): start_time\",\n \"13 <-- 3rd card in round If 4th card is not 25, then\",\n \"Hearts is 2 Spades is 3 Representing a \\\"State\\\" as an opening suit\",\n \"hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game,\",\n \"[] for hand in hands: p = 0 for card in hand: if\",\n \"phase. \\\"\\\"\\\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename\",\n \"238 Final Project: Bridge RL Agent <NAME> & <NAME> \\\"\\\"\\\" import copy import\",\n \"frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards)\",\n \"winner of the round. \\\"\\\"\\\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val =\",\n \"if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2,\",\n \"player_idx == 2: # Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1])\",\n \"highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3\",\n \"max_val, max_idx = card, idx return max_idx \\\"\\\"\\\" This function determines the declarer\",\n \"np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in range(52): for card_2 in\",\n \"** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) card_played = 24 If\",\n \"agent plays their highest card even though the highest card already played is\",\n \"agent_state = None agent_state_2 = None opening_suit = -1 # Each player plays\",\n \"= None player_idx = (round_winner + player) % 4 if player_idx == 2:\",\n \"if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and write out\",\n \"11, 20, 24, 38) The agent choose to play whichever remaining card has\",\n \"== 2: # Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state)\",\n \"y[max] = -1 max = np.argmax(y) policy.append(max) count += 1 game_file = \\\"Bridge_\\\"\",\n \"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions deals random cards. \\\"\\\"\\\" deck = list(range(52)) def shuffle_cards():\",\n \"card_played = 24 If 4th card is 25 (Diamond 14), then the agent\",\n \"barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta (want this to be positive):\",\n \"= 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995\",\n \"open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'a') as k: k.write( f\\\"{game +\",\n \"= 24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function write the policy at the end\",\n \"which states have been updated for this game # For each round for\",\n \"to be positive): {average_win_delta}\\\") print(f\\\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red\",\n \"outputs a winner. \\\"\\\"\\\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0])\",\n \"a card and must play a Diamond if it has one. Representing the\",\n \"\\\"\\\"\\\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\"\",\n \"cards_played) + round_winner) % 4 # Adjust the BridgeAgent weights. # If the\",\n \"print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\") ba = BridgeAgent() ba = game_summary(ba, True) # TESTING\",\n \"card % 13 == 10: p += 2 elif card % 13 ==\",\n \"functions deals random cards. \\\"\\\"\\\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13],\",\n \"+= 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\"\",\n \"range(card_1, 52): for card_3 in range(card_2, 52): for card_partner in [-1, card_1, card_2,\",\n \"= 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def __init__(self):\",\n \"Representing a \\\"State\\\" as an opening suit and frozenset of up to 3\",\n \"(suit + 1) * 13) if i in cards_in_hand]) if len(valid_cards) == 0:\",\n \"class BridgeAgent: def __init__(self): # We initialize all weights to 1 such that\",\n \"weights. # If the BridgeAgent or N wins. if round_winner == 0 or\",\n \"1 \\\"\\\"\\\" This function checks if the agent wins a round when there's\",\n \"namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS\",\n \"most points. Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\" def agent_declarer(hands): points = count_points(hands) # determines\",\n \"1) * 13) if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards =\",\n \"__init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT\",\n \"is not declarer and agent should start the play return False, -1 \\\"\\\"\\\"\",\n \"import datetime import numpy as np import random from collections import namedtuple \\\"\\\"\\\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\",\n \"by non-agents who play randomly. \\\"\\\"\\\" def play_random_card(suit, cards_in_hand): if suit == -1:\",\n \"partnership with the most points. Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\" def agent_declarer(hands): points =\",\n \"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def __init__(self): # We initialize all weights to 1 such\",\n \"that every card has an equal chance of being chosen. self.weights = {}\",\n \"= cards_in_hand # Choose the valid card with highest weight. # index_into_valid_counts =\",\n \"count += 1 game_file = \\\"Bridge_\\\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file,\",\n \"return max_idx \\\"\\\"\\\" This function determines the declarer based on partnership with the\",\n \"given that it is at that state. In this example, with state =\",\n \"a \\\"State\\\" where no cards have been played yet. Clubs is 0 Diamonds\",\n \"play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot plays card = play_random_card(opening_suit,\",\n \"BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function plays 13 rounds of 1 NT bridge\",\n \"for this game # For each round for _ in range(13): cards_played =\",\n \"player plays a card in order starting from round_winner for player in range(4):\",\n \"want to incrase the proportion with which we play 24. ba.add_win(state, card_played) \\\"\\\"\\\"\",\n \"card, does agent play lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards,\",\n \"52 cards given that it is at that state. In this example, with\",\n \"i in range(suit * 13, (suit + 1) * 13) if i in\",\n \"= card, idx return max_idx \\\"\\\"\\\" This function determines the declarer based on\",\n \"barf=barf_random) ba.game_num += 1 if (game + 1) % STATS_PER == 0: print(f\\\"{game\",\n \"Club 2 -> Club 14 Cards 13 -> 25 are Diamond 2 ->\",\n \"is 14 Representing a \\\"Suit\\\" as an integer: n/a is -1 <-- used\",\n \"decrease the proportion with which we play 24. ba.add_loss(state, card_played) \\\"\\\"\\\" def add_loss(self,\",\n \"k: k.write( f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\"\",\n \"the array of length-52 represets the proportion with which the agent should play\",\n \"hand # agent's partnership has more points and agent is declarer if points[0]\",\n \"BridgeAgent weights. # If the BridgeAgent or N wins. if round_winner == 0\",\n \"def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for idx, card in\",\n \"barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'a') as k: k.write(\",\n \"24 and 25 since a Diamond 13 and Diamond 14 will beat the\",\n \"'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52 #\",\n \"1) % 4 # the person to the right of the declarer starts\",\n \"Diamonds is 1 Hearts is 2 Spades is 3 Representing a \\\"State\\\" as\",\n \"Diamond 13 and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State =\",\n \"[0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True,\",\n \"are Heart 2 -> Heart 14 Cards 39 -> 51 are Spade 2\",\n \"barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \\\"\\\"\\\" hands[0]\",\n \"{} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1\",\n \"the weights here print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now()\",\n \"+ \\\".txt\\\", 'w') as f: for state in self.weights: f.write(\\\"State: suit {} |\",\n \"+= play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game + 1) %\",\n \"and frozenset of up to 3 \\\"Card\\\"-s: state = State(1, frozenset(23, 0)) We\",\n \"= game_summary(ba, True) # TESTING -- we don't change the weights here print(f\\\"TESTING\",\n \"\\\"\\\"\\\" This function determines the winner of the round. \\\"\\\"\\\" def determine_round_winner(suit, cards_played):\",\n \"play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit = 1 suit =\",\n \"EXAMPLE state = State(1, set(23, 0)) card_played = 24 If 4th card is\",\n \"+ round_winner) % 4 # Adjust the BridgeAgent weights. # If the BridgeAgent\",\n \"policy at the end of the data training phase. \\\"\\\"\\\" def write_policy(self, cards_in_hand,\",\n \"bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit.\",\n \"\\\" \\\" TRACKS PERFORMANCE OF BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def __init__(self):\",\n \"barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER)\",\n \"# records which states have been updated for this game # For each\",\n \"which we play 24. ba.add_win(state, card_played) \\\"\\\"\\\" def add_win(self, state, card_played): self.weights[state][card_played] *=\",\n \"= count_points(hands) # determines the number of points in each hand # agent's\",\n \"# Following the EXAMPLE: # suit = 1 suit = state.opening_suit # valid_cards\",\n \"Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\"\",\n \"all_valid_cards if i in hands[player_idx]]) if suit == -1: return # highest card\",\n \"If 4th card is 25 (Diamond 14), then the agent loses. We want\",\n \"partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards\",\n \"cards given that it is at that state. In this example, with state\",\n \"1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions deals random\",\n \"1) * 13) if i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand)\",\n \"p += 1 points.append(p) return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS PERFORMANCE OF BRIDGE\",\n \"the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust\",\n \"points[2] > points[0]: return True, 2 # agent is not declarer and agent\",\n \"= {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for\",\n \"for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in\",\n \"\\\" RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def __init__(self): # We initialize all\",\n \"very large values at indices 24 and 25 since a Diamond 13 and\",\n \"f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def main(): start_time = datetime.datetime.now() hands = [] # TRAINING\",\n \"Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\\\"State: suit\",\n \"== 10: p += 2 elif card % 13 == 9: p +=\",\n \"likely have very large values at indices 24 and 25 since a Diamond\",\n \"at indices 24 and 25 since a Diamond 13 and Diamond 14 will\",\n \"at that state. In this example, with state = (1, set(23, 0)), weights[state]\",\n \"GAME OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function plays 13 rounds of 1\",\n \"else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of\",\n \"+= 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\"\",\n \"= np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in range(52): for card_2\",\n \"= np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def\",\n \"np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3)\",\n \"weight. # index_into_valid_counts = 1 since 20 has a smaller weight than 24.\",\n \"# agent's partnership has more points and agent is declarer if points[0] +\",\n \"1 \\\"\\\"\\\" This function checks for any red flags based on what the\",\n \"Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening\",\n \"self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in\",\n \"deck[26:39], deck[39:52]] \\\"\\\"\\\" This function is used by non-agents who play randomly. \\\"\\\"\\\"\",\n \"= -1 max = np.argmax(y) policy.append(max) count += 1 game_file = \\\"Bridge_\\\" +\",\n \"in states_accessed: g.write(\\\"State: suit {} | cards played {} | partner's card {}\\\\nBest\",\n \"-1 \\\"\\\"\\\" This function counts the points in each hand. Note: Ace is\",\n \"declarer, d = agent_declarer(hands) \\\"\\\"\\\" hands[0] = North's cards hands[1] = East's cards\",\n \"opening_suit in range(4): for card_1 in range(52): for card_2 in range(card_1, 52): for\",\n \"played yet. Clubs is 0 Diamonds is 1 Hearts is 2 Spades is\",\n \"BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game in\",\n \"Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT =\",\n \"plays their highest card even though the highest card already played is higher\",\n \"function determines the winner of the round. \\\"\\\"\\\" def determine_round_winner(suit, cards_played): max_idx =\",\n \"14 Cards 39 -> 51 are Spade 2 -> Spade 14 Jack is\",\n \"as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def main(): start_time = datetime.datetime.now() hands =\",\n \"hands: p = 0 for card in hand: if card % 13 ==\",\n \"agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1\",\n \"points.append(p) return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS PERFORMANCE OF BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\"\",\n \"def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards):\",\n \"is higher than theirs. \\\"\\\"\\\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) >\",\n \"= 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL AGENT\",\n \"partners_cards) # 3 cards played + partner has played highest card, does agent\",\n \"= barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" +\",\n \"> points[1] + points[3] and points[2] > points[0]: return True, 2 # agent\",\n \"weight. card_played = ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def play_card(self, state, cards_in_hand): # Following the\",\n \"round. \\\"\\\"\\\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for idx,\",\n \"set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11, 20, 24, 38) The\",\n \"based on what the agent played. \\\"\\\"\\\" def assess_card_played(self, hands, card, suit, cards_played,\",\n \"with a Map from a \\\"State\\\" to an array of length-52: We call\",\n \"has played highest card, does agent play lowest card? do they beat their\",\n \"hand in hands: p = 0 for card in hand: if card %\",\n \"points = [] for hand in hands: p = 0 for card in\",\n \"partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY A SINGLE GAME\",\n \"opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner\",\n \"Agent can choose any card to play (only some are valid). NUM_GAMES_TRAIN =\",\n \"1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] +=\",\n \"# 5,000,000 self.game_num = 1 \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) #\",\n \"p += 4 elif card % 13 == 11: p += 3 elif\",\n \"card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: # if agent is\",\n \"hands = [] # TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\") ba = BridgeAgent() ba\",\n \"highest card even though the highest card already played is higher than theirs.\",\n \"BridgeAgent: def __init__(self): # We initialize all weights to 1 such that every\",\n \"not 25, then the agent wins. We want to incrase the proportion with\",\n \"the most points. Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\" def agent_declarer(hands): points = count_points(hands) #\",\n \"the agent loses. We want to decrease the proportion with which we play\",\n \"\\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def __init__(self): # We initialize all weights to 1\",\n \"Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 #\",\n \"1} / \\\", end=\\\"\\\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc =\",\n \"of the opening suit. if player == 0: opening_suit = card // 13\",\n \"play each of the 52 cards given that it is at that state.\",\n \"in each hand. Note: Ace is 12, 25, 38, 51 \\\"\\\"\\\" def count_points(hands):\",\n \"cards_in_hand) \\\"\\\"\\\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit =\",\n \"play return False, -1 \\\"\\\"\\\" This function counts the points in each hand.\",\n \"= np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS =\",\n \"the declarer starts the game NS_Wins = 0 # used to count total\",\n \"def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\" This function is used\",\n \"39 -> 51 are Spade 2 -> Spade 14 Jack is 11 Queen\",\n \"ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) +\",\n \"card even though the highest card already played is higher than theirs. \\\"\\\"\\\"\",\n \"cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) >\",\n \"ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and\",\n \"Red Flag Ratios - Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\\\")\",\n \"'w') as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf =\",\n \"card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card =\",\n \"opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: # if agent is declarer,\",\n \"in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the valid\",\n \"King is 13 Ace is 14 Representing a \\\"Suit\\\" as an integer: n/a\",\n \"for any red flags based on what the agent played. \\\"\\\"\\\" def assess_card_played(self,\",\n \"(1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23,\",\n \"card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000\",\n \"suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1) *\",\n \"Win Delta (want this to be positive): {average_win_delta}\\\") print(f\\\"Average Red Flag Ratios -\",\n \"on what the agent played. \\\"\\\"\\\" def assess_card_played(self, hands, card, suit, cards_played, player_idx,\",\n \"3 cards played and agent has higher cards, does it play highest card\",\n \"one higher card than what's been played. \\\"\\\"\\\" def higher_card(self, valid_cards, agent_valid_cards, card,\",\n \"card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed:\",\n \"[deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\" This function is used by non-agents who play\",\n \"right of the declarer starts the game NS_Wins = 0 # used to\",\n \"== 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning\",\n \"OF BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT\",\n \"their highest card even though the highest card already played is higher than\",\n \"return random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\" This function determines the winner of the round.\",\n \"Diamond if it has one. Representing the MDP with a Map from a\",\n \"Note: Ace is 12, 25, 38, 51 \\\"\\\"\\\" def count_points(hands): points = []\",\n \"And the array of length-52 represets the proportion with which the agent should\",\n \"it has Diamonds. In this example, agent will most likely play 24, which\",\n \"= Agent's cards hands[3] = West's cards \\\"\\\"\\\" round_winner = (d + 1)\",\n \"whichever remaining card has the highest weight. The agent must play a Diamond\",\n \"for card_partner in [-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2,\",\n \"-> Diamond 14 Cards 26 -> 38 are Heart 2 -> Heart 14\",\n \"FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions deals random cards. \\\"\\\"\\\" deck = list(range(52))\",\n \"self.weights: f.write(\\\"State: suit {} | cards played {} | partner's card {}\\\\nBest Card\",\n \"-1 # Each player plays a card in order starting from round_winner for\",\n \"frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in range(52):\",\n \"= np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta (want this to be positive): {average_win_delta}\\\") print(f\\\"Average\",\n \"agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else:\",\n \"we don't change the weights here print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST)\",\n \"points[1] + points[3] and points[2] > points[0]: return True, 2 # agent is\",\n \"elif card % 13 == 10: p += 2 elif card % 13\",\n \"declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0])\",\n \"or N wins. if round_winner == 0 or round_winner == 2: if ba\",\n \"play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d\",\n \"== -1: return random.choice(cards_in_hand) valid_cards = [i for i in range(suit * 13,\",\n \"wins. if round_winner == 0 or round_winner == 2: if ba and train:\",\n \"any card to play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST =\",\n \"= 10000 STATS_PER = 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class\",\n \"enumerate(cards_played): if suit * 13 <= card < (suit + 1) * 13\",\n \"is 3rd to play a card and must play a Diamond if it\",\n \"declarer based on partnership with the most points. Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\" def\",\n \"highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent has higher\",\n \"hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit +\",\n \"for player in range(4): card = None player_idx = (round_winner + player) %\",\n \"is not 25, then the agent wins. We want to incrase the proportion\",\n \"on {NUM_GAMES_TRAIN} games\\\") ba = BridgeAgent() ba = game_summary(ba, True) # TESTING --\",\n \"has a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards]\",\n \"0 with open(filename + \\\"_Last_Game.txt\\\", 'w') as g: g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with\",\n \"+ points[3] and points[2] > points[0]: return True, 2 # agent is not\",\n \"\\\"\\\"\\\" This function checks if the agent wins a round when there's three\",\n \"checks if the agent wins a round when there's three cards played already\",\n \"agent_card_played[1] = card else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx]) #\",\n \"\\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52 # Agent can choose any card to play\",\n \"# determines the number of points in each hand # agent's partnership has\",\n \"= card else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep\",\n \"agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit,\",\n \"opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997\",\n \"card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state\",\n \"1 such that every card has an equal chance of being chosen. self.weights\",\n \"13 == 12: p += 4 elif card % 13 == 11: p\",\n \"agent's partnership has more points and agent is declarer if points[0] + points[2]\",\n \"valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] +=\",\n \"state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE\",\n \"g: g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename + \\\".txt\\\", 'w') as f: for\",\n \"len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\" This function determines the winner\",\n \"# agent is not declarer and agent should start the play return False,\",\n \"): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] +=\",\n \"self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \\\"\\\"\\\" EXAMPLE state = State(1,\",\n \"write the policy at the end of the data training phase. \\\"\\\"\\\" def\",\n \"rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'a') as\",\n \"when there's three cards played already and the agent has at least one\",\n \"2 <-- first 2 cards in round card_played = 24 # Diamond 13\",\n \"<NAME> & <NAME> \\\"\\\"\\\" import copy import datetime import numpy as np import\",\n \"[] count = 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max =\",\n \"if card % 13 == 12: p += 4 elif card % 13\",\n \"== 9: p += 1 points.append(p) return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS PERFORMANCE\",\n \"\\\".csv\\\", 'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def main(): start_time = datetime.datetime.now()\",\n \"{average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" +\",\n \"\\\"\\\"\\\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha **\",\n \"Bridge RL Agent <NAME> & <NAME> \\\"\\\"\\\" import copy import datetime import numpy\",\n \"play 24. ba.add_win(state, card_played) \\\"\\\"\\\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 +\",\n \"13 == 9: p += 1 points.append(p) return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS\",\n \"== (NUM_GAMES_TRAIN - 1): policy = [] count = 0 for x in\",\n \"Spade 2 -> Spade 14 Jack is 11 Queen is 12 King is\",\n \"= np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This\",\n \"weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) #\",\n \"self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) card_played = 24\",\n \"rounds of 1 NT bridge and outputs a winner. \\\"\\\"\\\" def play_game(game, hands,\",\n \"for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba,\",\n \"\\\".txt\\\", 'w') as f: for state in self.weights: f.write(\\\"State: suit {} | cards\",\n \"card < (suit + 1) * 13 and card > max_val: max_val, max_idx\",\n \"| partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count +=\",\n \"We have a Diamond 12 and Club 2 with an opening suit of\",\n \"barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent\",\n \"declarer, they play their partner's cards if ba and declarer: agent_state_2 = State(opening_suit,\",\n \"a winner. \\\"\\\"\\\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards\",\n \"1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def __init__(self): #\",\n \"= 0.997 # 1,000 # self.alpha = 0.9995 # 10,000 # self.alpha =\",\n \"= [0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands),\",\n \"= namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\"\",\n \"rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\"\",\n \"len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1\",\n \"\\\"\\\"\\\" This functions deals random cards. \\\"\\\"\\\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck)\",\n \"the opening suit. if player == 0: opening_suit = card // 13 hands[player_idx].remove(card)\",\n \"* self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand =\",\n \"max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\" This function checks if the\",\n \"print(f\\\"Average Win Delta (want this to be positive): {average_win_delta}\\\") print(f\\\"Average Red Flag Ratios\",\n \"A SINGLE GAME OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function plays 13 rounds\",\n \"/ \\\", end=\\\"\\\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT\",\n \"in hands[player_idx]]) if suit == -1: return # highest card played so far\",\n \"* STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta\",\n \"# index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] =\",\n \"State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE SOME CONSTANTS \\\"\",\n \"rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) +\",\n \"2 -> Club 14 Cards 13 -> 25 are Diamond 2 -> Diamond\",\n \"(want this to be positive): {average_win_delta}\\\") print(f\\\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\\\")\",\n \"== 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins\",\n \"Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\"\",\n \"= play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit. if player ==\",\n \"State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha =\",\n \"cards. \\\"\\\"\\\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]]\",\n \"highest card already played is higher than theirs. \\\"\\\"\\\" def highest_card(self, valid_cards, agent_valid_cards,\",\n \"if suit == -1: return # highest card played so far is higher\",\n \"card % 13 == 11: p += 3 elif card % 13 ==\",\n \"DEFINE SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52 # Agent can choose any\",\n \"function checks if the agent plays their highest card even though the highest\",\n \"card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit. if player\",\n \"\\\" DEFINE SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52 # Agent can choose\",\n \"want to decrease the proportion with which we play 24. ba.add_loss(state, card_played) \\\"\\\"\\\"\",\n \"self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1\",\n \"_ in range(13): cards_played = [] agent_card_played = [-1, -1] agent_state = None\",\n \"= BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game\",\n \"agent has higher cards, does it play highest card or highest necessary card?\",\n \"0.997 # 1,000 # self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995\",\n \"+= 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2]\",\n \"weights to 1 such that every card has an equal chance of being\",\n \"random.choice(cards_in_hand) valid_cards = [i for i in range(suit * 13, (suit + 1)\",\n \"function checks for any red flags based on what the agent played. \\\"\\\"\\\"\",\n \"from a \\\"State\\\" to an array of length-52: We call this Map \\\"weights\\\".\",\n \"This function checks if the agent plays their highest card even though the\",\n \"0 or round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer:\",\n \"-1: return random.choice(cards_in_hand) valid_cards = [i for i in range(suit * 13, (suit\",\n \"\\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins =\",\n \"and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game,\",\n \"state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE\",\n \"\\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0]\",\n \"if agent is declarer, they play their partner's cards if ba and declarer:\",\n \"52): for card_partner in [-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1,\",\n \"should play each of the 52 cards given that it is at that\",\n \"than what's been played. \\\"\\\"\\\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if\",\n \"in hand: if card % 13 == 12: p += 4 elif card\",\n \"hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1]\",\n \"this example, with state = (1, set(23, 0)), weights[state] will likely have very\",\n \"barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] =\",\n \"card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] =\",\n \"card is not 25, then the agent wins. We want to incrase the\",\n \"11: p += 3 elif card % 13 == 10: p += 2\",\n \"red flags based on what the agent played. \\\"\\\"\\\" def assess_card_played(self, hands, card,\",\n \"hands[player_idx]) agent_card_played[1] = card else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx])\",\n \"card in order starting from round_winner for player in range(4): card = None\",\n \"# Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT\",\n \"cards played {} | partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card,\",\n \"\\\"weights\\\". And the array of length-52 represets the proportion with which the agent\",\n \"import random from collections import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \\\"Card\\\"\",\n \"play 24. ba.add_loss(state, card_played) \\\"\\\"\\\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 +\",\n \"= 0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num = 1\",\n \"= np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\" This function checks if the agent plays\",\n \"card and must play a Diamond if it has one. Representing the MDP\",\n \"def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards)\",\n \"based on partnership with the most points. Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\" def agent_declarer(hands):\",\n \"state = (1, set(23, 0)), weights[state] will likely have very large values at\",\n \"suit. if player == 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) #\",\n \"np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\" This\",\n \"25, then the agent wins. We want to incrase the proportion with which\",\n \"\\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'w') as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\"\",\n \"(suit + 1) * 13) if i in cards_in_hand] if len(valid_cards) == 0:\",\n \"from round_winner for player in range(4): card = None player_idx = (round_winner +\",\n \"print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\\\"Runtime: \\\", end_time\",\n \"1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) #\",\n \"played is higher than theirs. \\\"\\\"\\\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards)\",\n \"self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\" This function checks if the agent\",\n \"cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the valid card\",\n \"\\\"\\\"\\\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and\",\n \"= datetime.datetime.now() print(\\\"Runtime: \\\", end_time - start_time) # runtime if __name__ == \\\"__main__\\\":\",\n \"higher card even though their partner is guaranteed to win. \\\"\\\"\\\" def partner_win(self,\",\n \"k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags() barf_random =\",\n \"with open(filename + \\\".txt\\\", 'w') as f: for state in self.weights: f.write(\\\"State: suit\",\n \"return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS PERFORMANCE OF BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class\",\n \"10,000 # self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 #\",\n \"and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State', ['opening_suit',\",\n \"return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) +\",\n \"card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0: # if\",\n \"in range(52): for card_2 in range(card_1, 52): for card_3 in range(card_2, 52): for\",\n \"NS_Wins = 0 # used to count total wins in agent partnership states_accessed\",\n \"self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3)\",\n \"= ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card,\",\n \"24. ba.add_win(state, card_played) \\\"\\\"\\\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1\",\n \"player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random\",\n \"open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" + str(t) + \\\".csv\\\", 'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return\",\n \"train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if\",\n \"higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) >\",\n \"State(1, set(23, 0)) # Diamond 12, Club 2 <-- first 2 cards in\",\n \"[] # TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\") ba = BridgeAgent() ba = game_summary(ba,\",\n \"of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for\",\n \"cards hands[3] = West's cards \\\"\\\"\\\" round_winner = (d + 1) % 4\",\n \"(Diamond 14), then the agent loses. We want to decrease the proportion with\",\n \"card_played) \\\"\\\"\\\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha\",\n \"frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 #\",\n \"partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot\",\n \"To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY\",\n \"if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\" This function\",\n \"and agent has higher cards, does it play highest card or highest necessary\",\n \"cards_in_hand # Choose the valid card with highest weight. # index_into_valid_counts = 1\",\n \"the game NS_Wins = 0 # used to count total wins in agent\",\n \"self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS\",\n \"if state in states_accessed: g.write(\\\"State: suit {} | cards played {} | partner's\",\n \"self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\" This function checks if the agent\",\n \"p += 2 elif card % 13 == 9: p += 1 points.append(p)\",\n \"n/a is -1 <-- used in a \\\"State\\\" where no cards have been\",\n \"* 13)) valid_cards = np.array([i for i in all_valid_cards if i in cards_played])\",\n \"that it is at that state. In this example, with state = (1,\",\n \"iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'w') as k: k.write(\\\"game,\\\"\",\n \"more points and agent is declarer if points[0] + points[2] > points[1] +\",\n \"to an array of length-52: We call this Map \\\"weights\\\". And the array\",\n \"since a Diamond 13 and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\"\",\n \"<filename>bridge_RL_agent_v16.py \\\"\\\"\\\" CS 238 Final Project: Bridge RL Agent <NAME> & <NAME> \\\"\\\"\\\"\",\n \"max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card\",\n \"\\\"\\\"\\\" hands[0] = North's cards hands[1] = East's cards hands[2] = Agent's cards\",\n \"to count total wins in agent partnership states_accessed = [] # records which\",\n \"as an integer: n/a is -1 <-- used in a \\\"State\\\" where no\",\n \"13 and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State',\",\n \"len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ):\",\n \"\\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def __init__(self): # We\",\n \"cards hands[2] = Agent's cards hands[3] = West's cards \\\"\\\"\\\" round_winner = (d\",\n \"range(4): card = None player_idx = (round_winner + player) % 4 if player_idx\",\n \"card, idx return max_idx \\\"\\\"\\\" This function determines the declarer based on partnership\",\n \"> max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0]\",\n \"suit {} | cards played {} | partner's card {}\\\\nBest Card To Play:\",\n \"14 Representing a \\\"Suit\\\" as an integer: n/a is -1 <-- used in\",\n \"play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num +=\",\n \"0)) # Diamond 12, Club 2 <-- first 2 cards in round card_played\",\n \"card than what's been played. \\\"\\\"\\\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards):\",\n \"\\\"\\\"\\\" This function checks if the agent plays a higher card even though\",\n \"if round_winner == 0 or round_winner == 2: if ba and train: ba.add_win(agent_state,\",\n \"play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx\",\n \"0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max\",\n \"> 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1\",\n \"and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1\",\n \"AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def __init__(self): # We initialize all weights to\",\n \"1 game_file = \\\"Bridge_\\\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return\",\n \"if i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\"\",\n \"in round If 4th card is not 25, then the agent wins. We\",\n \"SINGLE GAME OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function plays 13 rounds of\",\n \"person to the right of the declarer starts the game NS_Wins = 0\",\n \"some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \\\"\\\"\\\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\",\n \"cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards) in\",\n \"with which the agent should play each of the 52 cards given that\",\n \"\\\"\\\"\\\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename +\",\n \"an integer: n/a is -1 <-- used in a \\\"State\\\" where no cards\",\n \"EXAMPLE state = State(1, set(23, 0)) # Diamond 12, Club 2 <-- first\",\n \"cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY A SINGLE GAME OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\"\",\n \"= State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha\",\n \"51 \\\"\\\"\\\" def count_points(hands): points = [] for hand in hands: p =\",\n \"determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for idx, card in enumerate(cards_played):\",\n \"round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the BridgeAgent weights.\",\n \"partnership states_accessed = [] # records which states have been updated for this\",\n \"set(23, 0)) card_played = 24 If 4th card is 25 (Diamond 14), then\",\n \"suit = 1 suit = state.opening_suit # valid_cards = [20, 24] valid_cards =\",\n \"\\\"\\\"\\\" This function plays 13 rounds of 1 NT bridge and outputs a\",\n \"add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\"\",\n \"suit of Diamonds. The agent is 3rd to play a card and must\",\n \"highest card played so far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards,\",\n \"For each round for _ in range(13): cards_played = [] agent_card_played = [-1,\",\n \"if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else:\",\n \"and write out policy if ba and game == (NUM_GAMES_TRAIN - 1): policy\",\n \"elif player_idx == 0: # if agent is declarer, they play their partner's\",\n \"RL Agent <NAME> & <NAME> \\\"\\\"\\\" import copy import datetime import numpy as\",\n \"games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\\\"Runtime: \\\", end_time - start_time) #\",\n \"NUM_ACTIONS = 52 # Agent can choose any card to play (only some\",\n \"# used to count total wins in agent partnership states_accessed = [] #\",\n \"agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx == 0:\",\n \"valid_cards = cards_in_hand # Choose the valid card with highest weight. # index_into_valid_counts\",\n \"partner has played highest card, does agent play lowest card? do they beat\",\n \"shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\" This function is used by\",\n \"== 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\" This function determines the winner of\",\n \"returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function write the policy at\",\n \"__init__(self): # We initialize all weights to 1 such that every card has\",\n \"higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and\",\n \"in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count += 1 game_file\",\n \"-1 max_val = -1 for idx, card in enumerate(cards_played): if suit * 13\",\n \"the agent plays their highest card even though the highest card already played\",\n \"policy.append(max) count += 1 game_file = \\\"Bridge_\\\" + str(game + 1) ba.write_policy(agents_cards, policy,\",\n \"this example, agent will most likely play 24, which beats 23 <-- hopefully\",\n \"card in round If 4th card is not 25, then the agent wins.\",\n \"card in enumerate(cards_played): if suit * 13 <= card < (suit + 1)\",\n \"number of points in each hand # agent's partnership has more points and\",\n \"= State(1, set(23, 0)) # Diamond 12, Club 2 <-- first 2 cards\",\n \"# the person to the right of the declarer starts the game NS_Wins\",\n \"first 2 cards in round card_played = 24 # Diamond 13 <-- 3rd\",\n \"2 cards in round card_played = 24 # Diamond 13 <-- 3rd card\",\n \"with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'w') as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\"\",\n \"= [0] NS_Wins_random = [0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1]\",\n \"None player_idx = (round_winner + player) % 4 if player_idx == 2: #\",\n \"BridgeAgent() ba = game_summary(ba, True) # TESTING -- we don't change the weights\",\n \"training phase. \\\"\\\"\\\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with\",\n \"higher than theirs. \\\"\\\"\\\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1\",\n \"\\\"\\\"\\\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and\",\n \"if the agent wins a round when there's three cards played already and\",\n \"with state = (1, set(23, 0)), weights[state] will likely have very large values\",\n \"'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def main(): start_time = datetime.datetime.now() hands\",\n \"> max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] +=\",\n \"which the agent should play each of the 52 cards given that it\",\n \"will most likely play 24, which beats 23 <-- hopefully 24 has the\",\n \"card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands,\",\n \"* 13, (suit + 1) * 13)) valid_cards = np.array([i for i in\",\n \"cards \\\"\\\"\\\" round_winner = (d + 1) % 4 # the person to\",\n \"// 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played)\",\n \"\\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins\",\n \"integer: Cards 0 -> 12 are Club 2 -> Club 14 Cards 13\",\n \"0 Diamonds is 1 Hearts is 2 Spades is 3 Representing a \\\"State\\\"\",\n \"\\\"\\\"\\\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2])\",\n \"1,000 # self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995 # 100,000\",\n \"# 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \\\"\\\"\\\" EXAMPLE\",\n \"valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function write the policy at the end of the data\",\n \"Club 2 <-- first 2 cards in round card_played = 24 # Diamond\",\n \"agent has at least one higher card than what's been played. \\\"\\\"\\\" def\",\n \"for card in hand: if card % 13 == 12: p += 4\",\n \"partner's cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card\",\n \"card_2 in range(card_1, 52): for card_3 in range(card_2, 52): for card_partner in [-1,\",\n \"* 13 <= card < (suit + 1) * 13 and card >\",\n \"what's been played. \\\"\\\"\\\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played)\",\n \"play their partner's cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0])\",\n \"player in range(4): card = None player_idx = (round_winner + player) % 4\",\n \"is declarer if points[0] + points[2] > points[1] + points[3] and points[2] >\",\n \"checks for any red flags based on what the agent played. \\\"\\\"\\\" def\",\n \"count_points(hands) # determines the number of points in each hand # agent's partnership\",\n \"checks if the agent plays their highest card even though the highest card\",\n \"def agent_declarer(hands): points = count_points(hands) # determines the number of points in each\",\n \"# 10,000 # self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000\",\n \"in range(suit * 13, (suit + 1) * 13) if i in cards_in_hand])\",\n \"we play 24. ba.add_win(state, card_played) \\\"\\\"\\\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1\",\n \"Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\\\"State: suit {} |\",\n \"max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\" This function checks if the\",\n \"numpy as np import random from collections import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE\",\n \"deals random cards. \\\"\\\"\\\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26],\",\n \"can choose any card to play (only some are valid). NUM_GAMES_TRAIN = 10000\",\n \"has at least one higher card than what's been played. \\\"\\\"\\\" def higher_card(self,\",\n \"np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative def clear_red_flags(self):\",\n \"range(52): for card_2 in range(card_1, 52): for card_3 in range(card_2, 52): for card_partner\",\n \"partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2]\",\n \"incrase the proportion with which we play 24. ba.add_win(state, card_played) \\\"\\\"\\\" def add_win(self,\",\n \"+= 1 \\\"\\\"\\\" This function checks for any red flags based on what\",\n \"max_idx = -1 max_val = -1 for idx, card in enumerate(cards_played): if suit\",\n \"hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d =\",\n \"This function plays 13 rounds of 1 NT bridge and outputs a winner.\",\n \"in all_valid_cards if i in hands[player_idx]]) if suit == -1: return # highest\",\n \"1 since 20 has a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards])\",\n \"-1 for idx, card in enumerate(cards_played): if suit * 13 <= card <\",\n \"namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \\\"Card\\\" as an integer: Cards 0\",\n \"games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) *\",\n \"state, cards_in_hand): # Following the EXAMPLE: # suit = 1 suit = state.opening_suit\",\n \"if it has one. Representing the MDP with a Map from a \\\"State\\\"\",\n \"for i in all_valid_cards if i in hands[player_idx]]) if suit == -1: return\",\n \"of length-52: We call this Map \\\"weights\\\". And the array of length-52 represets\",\n \"are Club 2 -> Club 14 Cards 13 -> 25 are Diamond 2\",\n \"suit and frozenset of up to 3 \\\"Card\\\"-s: state = State(1, frozenset(23, 0))\",\n \"don't change the weights here print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time\",\n \"hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played,\",\n \"in agent partnership states_accessed = [] # records which states have been updated\",\n \"Cards 13 -> 25 are Diamond 2 -> Diamond 14 Cards 26 ->\",\n \"13)) valid_cards = np.array([i for i in all_valid_cards if i in cards_played]) agent_valid_cards\",\n \"f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative statistics\",\n \"return ba def main(): start_time = datetime.datetime.now() hands = [] # TRAINING print(f\\\"TRAINING\",\n \"player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1) * 13)) valid_cards\",\n \"+= 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1]\",\n \"Spade 14 Jack is 11 Queen is 12 King is 13 Ace is\",\n \"Keep track of the opening suit. if player == 0: opening_suit = card\",\n \"initialize all weights to 1 such that every card has an equal chance\",\n \"then the agent wins. We want to incrase the proportion with which we\",\n \"state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) #\",\n \"1.0) # self.alpha = 0.997 # 1,000 # self.alpha = 0.9995 # 10,000\",\n \"Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state,\",\n \"+ \\\".csv\\\", 'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def main(): start_time =\",\n \"Cards 39 -> 51 are Spade 2 -> Spade 14 Jack is 11\",\n \"self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3) # Cumulative\",\n \"flags based on what the agent played. \\\"\\\"\\\" def assess_card_played(self, hands, card, suit,\",\n \"been played. \\\"\\\"\\\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) ==\",\n \"BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game in range(iterations): hands =\",\n \"self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1\",\n \"to incrase the proportion with which we play 24. ba.add_win(state, card_played) \\\"\\\"\\\" def\",\n \"STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1)\",\n \"what the agent played. \\\"\\\"\\\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards):\",\n \"partners_cards) elif player_idx == 0: # if agent is declarer, they play their\",\n \"does it play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played,\",\n \"being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit\",\n \"self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\" This function checks if the agent plays a higher\",\n \"= [-1, -1] agent_state = None agent_state_2 = None opening_suit = -1 #\",\n \"<= card < (suit + 1) * 13 and card > max_val: max_val,\",\n \"suit = state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i for i\",\n \"self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num =\",\n \"suit * 13 <= card < (suit + 1) * 13 and card\",\n \"= np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta (want this to\",\n \"np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta (want this to be positive): {average_win_delta}\\\") print(f\\\"Average Red\",\n \"= East's cards hands[2] = Agent's cards hands[3] = West's cards \\\"\\\"\\\" round_winner\",\n \"declarer and agent should start the play return False, -1 \\\"\\\"\\\" This function\",\n \"agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \\\"\\\"\\\" hands[0] = North's cards hands[1]\",\n \"opening_suit = -1 # Each player plays a card in order starting from\",\n \"): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] +=\",\n \"the points in each hand. Note: Ace is 12, 25, 38, 51 \\\"\\\"\\\"\",\n \"BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) #\",\n \"\\\"\\\"\\\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit *\",\n \"# returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function write the policy\",\n \"here print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\\\"Runtime: \\\",\",\n \"the 52 cards given that it is at that state. In this example,\",\n \"\\\"Card\\\" as an integer: Cards 0 -> 12 are Club 2 -> Club\",\n \"ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max] =\",\n \"NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS,\",\n \"= None opening_suit = -1 # Each player plays a card in order\",\n \"4 # Adjust the BridgeAgent weights. # If the BridgeAgent or N wins.\",\n \"has more points and agent is declarer if points[0] + points[2] > points[1]\",\n \"1 suit = state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i for\",\n \"last game, determine and write out policy if ba and game == (NUM_GAMES_TRAIN\",\n \"self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4):\",\n \"| cards played {} | partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played,\",\n \"13 <= card < (suit + 1) * 13 and card > max_val:\",\n \"Following the EXAMPLE: # suit = 1 suit = state.opening_suit # valid_cards =\",\n \"self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1\",\n \"'a') as k: k.write( f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\"\",\n \"or round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2,\",\n \"# suit = 1 suit = state.opening_suit # valid_cards = [20, 24] valid_cards\",\n \"- Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" + str(t) + \\\".csv\\\", 'w') as\",\n \"+ 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with\",\n \"play whichever remaining card has the highest weight. The agent must play a\",\n \"with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'a') as k: k.write( f\\\"{game\",\n \"play randomly. \\\"\\\"\\\" def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards\",\n \"remaining card has the highest weight. The agent must play a Diamond if\",\n \"+= 2 elif card % 13 == 9: p += 1 points.append(p) return\",\n \"valid_cards = np.array([i for i in all_valid_cards if i in cards_played]) agent_valid_cards =\",\n \"100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num\",\n \"the BridgeAgent or N wins. if round_winner == 0 or round_winner == 2:\",\n \"ba = BridgeAgent() ba = game_summary(ba, True) # TESTING -- we don't change\",\n \"valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function write the policy at the\",\n \"start the play return False, -1 \\\"\\\"\\\" This function counts the points in\",\n \"proportion with which we play 24. ba.add_win(state, card_played) \\\"\\\"\\\" def add_win(self, state, card_played):\",\n \"NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL\",\n \"= state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i for i in\",\n \"a \\\"Card\\\" as an integer: Cards 0 -> 12 are Club 2 ->\",\n \"round_winner for player in range(4): card = None player_idx = (round_winner + player)\",\n \"agent wins a round when there's three cards played already and the agent\",\n \"if suit == -1: return random.choice(cards_in_hand) valid_cards = [i for i in range(suit\",\n \"out policy if ba and game == (NUM_GAMES_TRAIN - 1): policy = []\",\n \"0 -> 12 are Club 2 -> Club 14 Cards 13 -> 25\",\n \"+= 4 elif card % 13 == 11: p += 3 elif card\",\n \"ba=None, barf=barf_random) ba.game_num += 1 if (game + 1) % STATS_PER == 0:\",\n \"# Adjust the BridgeAgent weights. # If the BridgeAgent or N wins. if\",\n \"% 13 == 10: p += 2 elif card % 13 == 9:\",\n \"play a card and must play a Diamond if it has one. Representing\",\n \"in hands: p = 0 for card in hand: if card % 13\",\n \"round when there's three cards played already and the agent has at least\",\n \"and card > max_val: max_val, max_idx = card, idx return max_idx \\\"\\\"\\\" This\",\n \"function determines the declarer based on partnership with the most points. Return: (agent_is_declarer,\",\n \"N wins. if round_winner == 0 or round_winner == 2: if ba and\",\n \"card % 13 == 9: p += 1 points.append(p) return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\"\",\n \"agent is declarer, they play their partner's cards if ba and declarer: agent_state_2\",\n \"+= 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\" This function checks if the agent wins\",\n \"updated for this game # For each round for _ in range(13): cards_played\",\n \"change the weights here print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time =\",\n \"+= 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0]\",\n \"return random.choice(cards_in_hand) valid_cards = [i for i in range(suit * 13, (suit +\",\n \"# Agent can choose any card to play (only some are valid). NUM_GAMES_TRAIN\",\n \"= [] # records which states have been updated for this game #\",\n \"= State(1, frozenset(23, 0)) We have a Diamond 12 and Club 2 with\",\n \"it is at that state. In this example, with state = (1, set(23,\",\n \"if player_idx == 2: # Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played),\",\n \"f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative statistics on red flags for every STATS_PER games.\",\n \"else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx,\",\n \"13 Ace is 14 Representing a \\\"Suit\\\" as an integer: n/a is -1\",\n \"agent should play each of the 52 cards given that it is at\",\n \"(game + 1) % STATS_PER == 0: print(f\\\"{game + 1} / \\\", end=\\\"\\\",\",\n \"2 Spades is 3 Representing a \\\"State\\\" as an opening suit and frozenset\",\n \"if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] +=\",\n \"valid card with highest weight. # index_into_valid_counts = 1 since 20 has a\",\n \"= 0 # used to count total wins in agent partnership states_accessed =\",\n \"ba.game_num += 1 if (game + 1) % STATS_PER == 0: print(f\\\"{game +\",\n \"= agent_declarer(hands) \\\"\\\"\\\" hands[0] = North's cards hands[1] = East's cards hands[2] =\",\n \"We call this Map \\\"weights\\\". And the array of length-52 represets the proportion\",\n \"count += 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions\",\n \"def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13,\",\n \"BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT =\",\n \"player_idx == 0: # if agent is declarer, they play their partner's cards\",\n \"card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state\",\n \"chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in\",\n \"+ 1) * 13 and card > max_val: max_val, max_idx = card, idx\",\n \"card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \\\"\\\"\\\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\",\n \"than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns\",\n \"BridgeAgent or N wins. if round_winner == 0 or round_winner == 2: if\",\n \"np import random from collections import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a\",\n \"Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\" def agent_declarer(hands): points = count_points(hands) # determines the number\",\n \"copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \\\"\\\"\\\" hands[0] = North's cards\",\n \"cards played and agent has higher cards, does it play highest card or\",\n \"This function checks for any red flags based on what the agent played.\",\n \"# self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995 # 100,000 self.alpha\",\n \"cards_played, player_idx, partners_cards) elif player_idx == 0: # if agent is declarer, they\",\n \"[20, 24] valid_cards = np.array([i for i in range(suit * 13, (suit +\",\n \"state = State(1, set(23, 0)) card_played = 24 If 4th card is 25\",\n \"though the highest card already played is higher than theirs. \\\"\\\"\\\" def highest_card(self,\",\n \"flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT\",\n \"card_1 in range(52): for card_2 in range(card_1, 52): for card_3 in range(card_2, 52):\",\n \"valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1\",\n \"choose any card to play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST\",\n \"track of the opening suit. if player == 0: opening_suit = card //\",\n \"opening suit and frozenset of up to 3 \\\"Card\\\"-s: state = State(1, frozenset(23,\",\n \"[-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state]\",\n \"f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative statistics on red flags for every\",\n \"ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \\\"\\\"\\\"\",\n \"NS_Wins = [0] NS_Wins_random = [0] for game in range(iterations): hands = shuffle_cards()\",\n \"+ str(t) + \\\".csv\\\", 'a') as k: k.write( f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] -\",\n \"def __init__(self): # We initialize all weights to 1 such that every card\",\n \"f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative statistics on red flags for every STATS_PER games. barf.clear_red_flags()\",\n \"declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and write out policy\",\n \"= play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot plays card =\",\n \"agent play lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played,\",\n \"<-- 3rd card in round If 4th card is not 25, then the\",\n \"play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit. if player == 0:\",\n \"the data training phase. \\\"\\\"\\\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count =\",\n \"14 Jack is 11 Queen is 12 King is 13 Ace is 14\",\n \"red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random))\",\n \"game_file = \\\"Bridge_\\\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins\",\n \"in round card_played = 24 # Diamond 13 <-- 3rd card in round\",\n \"is 12 King is 13 Ace is 14 Representing a \\\"Suit\\\" as an\",\n \"return # highest card played so far is higher than agent's highest card\",\n \"for state in self.weights: f.write(\\\"State: suit {} | cards played {} | partner's\",\n \"\\\"Bridge_\\\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba,\",\n \"range(4): for card_1 in range(52): for card_2 in range(card_1, 52): for card_3 in\",\n \"str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN):\",\n \"We want to incrase the proportion with which we play 24. ba.add_win(state, card_played)\",\n \"and agent should start the play return False, -1 \\\"\\\"\\\" This function counts\",\n \"range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] +=\",\n \"agent should start the play return False, -1 \\\"\\\"\\\" This function counts the\",\n \"card = None player_idx = (round_winner + player) % 4 if player_idx ==\",\n \"k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags() barf_random\",\n \"def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename + \\\"_Last_Game.txt\\\",\",\n \"# 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000\",\n \"determines the number of points in each hand # agent's partnership has more\",\n \"-1)] = np.full(NUM_ACTIONS, 1.0) for opening_suit in range(4): for card_1 in range(52): for\",\n \"points in each hand. Note: Ace is 12, 25, 38, 51 \\\"\\\"\\\" def\",\n \"card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent has higher cards,\",\n \"self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) card_played = 24 If 4th\",\n \"np.zeros(3) \\\"\\\"\\\" This function checks if the agent plays their highest card even\",\n \"\\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'a') as k: k.write( f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1]\",\n \"\\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS\",\n \"data training phase. \\\"\\\"\\\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0\",\n \"then the agent loses. We want to decrease the proportion with which we\",\n \"max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1]\",\n \"wins in agent partnership states_accessed = [] # records which states have been\",\n \"# index_into_valid_counts = 1 since 20 has a smaller weight than 24. #\",\n \"round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1])\",\n \"that state. In this example, with state = (1, set(23, 0)), weights[state] will\",\n \"{} | cards played {} | partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit,\",\n \"not declarer and agent should start the play return False, -1 \\\"\\\"\\\" This\",\n \"i in all_valid_cards if i in hands[player_idx]]) if suit == -1: return #\",\n \"NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent =\",\n \"# TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\") ba = BridgeAgent() ba = game_summary(ba, True)\",\n \"card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played + partner has\",\n \"4 elif card % 13 == 11: p += 3 elif card %\",\n \"Ace is 14 Representing a \\\"Suit\\\" as an integer: n/a is -1 <--\",\n \"max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\" This function checks for any\",\n \"write_policy(self, cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename + \\\"_Last_Game.txt\\\", 'w')\",\n \"{NUM_GAMES_TEST} games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\\\"Runtime: \\\", end_time - start_time)\",\n \"38, 51 \\\"\\\"\\\" def count_points(hands): points = [] for hand in hands: p\",\n \"TESTING -- we don't change the weights here print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\") game_summary(ba,\",\n \"proportion with which the agent should play each of the 52 cards given\",\n \"= copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \\\"\\\"\\\" hands[0] = North's\",\n \"card % 13 == 12: p += 4 elif card % 13 ==\",\n \"Project: Bridge RL Agent <NAME> & <NAME> \\\"\\\"\\\" import copy import datetime import\",\n \"play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game + 1) % STATS_PER\",\n \"0 for card in hand: if card % 13 == 12: p +=\",\n \"set(23, 0)), weights[state] will likely have very large values at indices 24 and\",\n \"all weights to 1 such that every card has an equal chance of\",\n \"for card_1 in range(52): for card_2 in range(card_1, 52): for card_3 in range(card_2,\",\n \"at least one higher card than what's been played. \\\"\\\"\\\" def higher_card(self, valid_cards,\",\n \"1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if\",\n \"return True, 2 # agent is not declarer and agent should start the\",\n \"elif card % 13 == 11: p += 3 elif card % 13\",\n \"barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t)\",\n \"to the right of the declarer starts the game NS_Wins = 0 #\",\n \"necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played + partner\",\n \"has Diamonds. In this example, agent will most likely play 24, which beats\",\n \"+ \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'a') as k: k.write( f\\\"{game + 1},\\\"\",\n \"i in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for i in\",\n \"Each player plays a card in order starting from round_winner for player in\",\n \"game_summary(ba, True) # TESTING -- we don't change the weights here print(f\\\"TESTING on\",\n \"points and agent is declarer if points[0] + points[2] > points[1] + points[3]\",\n \"if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\" This function\",\n \"NS_Wins_random = [0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game,\",\n \"4th card is 25 (Diamond 14), then the agent loses. We want to\",\n \"PLAY A SINGLE GAME OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function plays 13\",\n \"if points[0] + points[2] > points[1] + points[3] and points[2] > points[0]: return\",\n \"\\\"\\\"\\\" This function write the policy at the end of the data training\",\n \"return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function write the policy at the end of the\",\n \"train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine\",\n \"function counts the points in each hand. Note: Ace is 12, 25, 38,\",\n \"Map from a \\\"State\\\" to an array of length-52: We call this Map\",\n \"class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3)\",\n \"on {NUM_GAMES_TEST} games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\\\"Runtime: \\\", end_time -\",\n \"train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands)\",\n \"12, 25, 38, 51 \\\"\\\"\\\" def count_points(hands): points = [] for hand in\",\n \"agent must play a Diamond if it has Diamonds. In this example, agent\",\n \"1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] +=\",\n \"Heart 2 -> Heart 14 Cards 39 -> 51 are Spade 2 ->\",\n \"If 4th card is not 25, then the agent wins. We want to\",\n \"+ \\\".csv\\\", 'a') as k: k.write( f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\"\",\n \"to play a card and must play a Diamond if it has one.\",\n \"\\\" \\\" DEFINE SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52 # Agent can\",\n \"agent loses. We want to decrease the proportion with which we play 24.\",\n \"This function checks if the agent wins a round when there's three cards\",\n \"self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha =\",\n \"3 cards played + partner has played highest card, does agent play lowest\",\n \"# self.alpha = 0.997 # 1,000 # self.alpha = 0.9995 # 10,000 #\",\n \"weights here print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\") game_summary(ba, False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\\\"Runtime:\",\n \"game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'w') as\",\n \"of the data training phase. \\\"\\\"\\\" def write_policy(self, cards_in_hand, policy, filename, states_accessed): count\",\n \"= np.argmax(y) while max in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max)\",\n \"highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played +\",\n \"24 # Diamond 13 <-- 3rd card in round If 4th card is\",\n \"range(suit * 13, (suit + 1) * 13) if i in cards_in_hand] if\",\n \"ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and write out policy if\",\n \"(len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2]\",\n \"OF BRIDGE Representing a \\\"Card\\\" as an integer: Cards 0 -> 12 are\",\n \"Representing the MDP with a Map from a \\\"State\\\" to an array of\",\n \"\\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8,\",\n \"= 0 with open(filename + \\\"_Last_Game.txt\\\", 'w') as g: g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand))\",\n \"x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count += 1 game_file =\",\n \"statistics on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta\",\n \"copy import datetime import numpy as np import random from collections import namedtuple\",\n \"-> Club 14 Cards 13 -> 25 are Diamond 2 -> Diamond 14\",\n \"play a Diamond if it has one. Representing the MDP with a Map\",\n \"as k: k.write( f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\"\",\n \"38) The agent choose to play whichever remaining card has the highest weight.\",\n \"lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \\\"\\\"\\\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\",\n \"the highest weight. card_played = ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def play_card(self, state, cards_in_hand): #\",\n \"agent_card_played[1]) NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer:\",\n \"We initialize all weights to 1 such that every card has an equal\",\n \"+= 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\"\",\n \"function is used by non-agents who play randomly. \\\"\\\"\\\" def play_random_card(suit, cards_in_hand): if\",\n \"partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY A SINGLE GAME OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\"\",\n \"TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\") ba = BridgeAgent() ba = game_summary(ba, True) #\",\n \"\\\" \\\" RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def __init__(self): # We initialize\",\n \"declarer starts the game NS_Wins = 0 # used to count total wins\",\n \"list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\" This function is\",\n \"max_idx = card, idx return max_idx \\\"\\\"\\\" This function determines the declarer based\",\n \"policy[count])) if state in states_accessed: g.write(\\\"State: suit {} | cards played {} |\",\n \"= np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT = np.zeros(3)\",\n \"24, 38) The agent choose to play whichever remaining card has the highest\",\n \"= shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands,\",\n \"cards_played): max_idx = -1 max_val = -1 for idx, card in enumerate(cards_played): if\",\n \"= barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\",\",\n \"partner is guaranteed to win. \\\"\\\"\\\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards):\",\n \"add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\"\",\n \"played. \\\"\\\"\\\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3\",\n \"the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\"\",\n \"Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\" This function checks\",\n \"order starting from round_winner for player in range(4): card = None player_idx =\",\n \"open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'w') as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\"\",\n \"12 and Club 2 with an opening suit of Diamonds. The agent is\",\n \"# 1,000 # self.alpha = 0.9995 # 10,000 # self.alpha = 0.99995 #\",\n \"will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\",\n \"= np.array([i for i in all_valid_cards if i in hands[player_idx]]) if suit ==\",\n \"\\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \\\"Card\\\" as an integer: Cards 0 ->\",\n \"- 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average\",\n \"{}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename + \\\".txt\\\", 'w') as f: for state in self.weights: f.write(\\\"State:\",\n \"the agent wins. We want to incrase the proportion with which we play\",\n \"in range(4): for card_1 in range(52): for card_2 in range(card_1, 52): for card_3\",\n \"# Diamond 12, Club 2 <-- first 2 cards in round card_played =\",\n \"This functions deals random cards. \\\"\\\"\\\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return\",\n \"= 24 # Diamond 13 <-- 3rd card in round If 4th card\",\n \"and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card\",\n \"i in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if i in\",\n \"import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \\\"Card\\\" as an integer: Cards\",\n \"12 are Club 2 -> Club 14 Cards 13 -> 25 are Diamond\",\n \"each round for _ in range(13): cards_played = [] agent_card_played = [-1, -1]\",\n \"and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if\",\n \"This function checks if the agent plays a higher card even though their\",\n \"ba and game == (NUM_GAMES_TRAIN - 1): policy = [] count = 0\",\n \"- Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) +\",\n \"barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'a')\",\n \"idx return max_idx \\\"\\\"\\\" This function determines the declarer based on partnership with\",\n \"# highest card played so far is higher than agent's highest card self.highest_card(valid_cards,\",\n \"*= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1,\",\n \"% 13 == 9: p += 1 points.append(p) return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\"\",\n \"agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent has\",\n \"self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state =\",\n \"in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max]\",\n \"with which we play 24. ba.add_loss(state, card_played) \\\"\\\"\\\" def add_loss(self, state, card_played): self.weights[state][card_played]\",\n \"['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS =\",\n \"Diamonds. The agent is 3rd to play a card and must play a\",\n \"(agent_is_declarer, declarer_idx) \\\"\\\"\\\" def agent_declarer(hands): points = count_points(hands) # determines the number of\",\n \"= 52 # Agent can choose any card to play (only some are\",\n \"= BridgeAgent() ba = game_summary(ba, True) # TESTING -- we don't change the\",\n \"np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards]\",\n \"in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards):\",\n \"This function write the policy at the end of the data training phase.\",\n \"already played is higher than theirs. \\\"\\\"\\\" def highest_card(self, valid_cards, agent_valid_cards, card): if\",\n \"which we play 24. ba.add_loss(state, card_played) \\\"\\\"\\\" def add_loss(self, state, card_played): self.weights[state][card_played] /=\",\n \"card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\"\",\n \"range(suit * 13, (suit + 1) * 13) if i in cards_in_hand]) if\",\n \"state.cards_played, state.partners_card, policy[count])) count += 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\"\",\n \"((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT)\",\n \"open(filename + \\\"_Last_Game.txt\\\", 'w') as g: g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename +\",\n \"{} | partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if\",\n \"** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0, 1,\",\n \"Clubs is 0 Diamonds is 1 Hearts is 2 Spades is 3 Representing\",\n \"24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function write the policy at the end of\",\n \"== 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not\",\n \"= (d + 1) % 4 # the person to the right of\",\n \"partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) >\",\n \"with the most points. Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\" def agent_declarer(hands): points = count_points(hands)\",\n \"cards played already and the agent has at least one higher card than\",\n \"False, iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\\\"Runtime: \\\", end_time - start_time) # runtime if\",\n \"Jack is 11 Queen is 12 King is 13 Ace is 14 Representing\",\n \"3 elif card % 13 == 10: p += 2 elif card %\",\n \"card_played = 24 # Diamond 13 <-- 3rd card in round If 4th\",\n \"np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\" This function checks if the agent plays their\",\n \"if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1\",\n \"cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1) * 13))\",\n \"of up to 3 \\\"Card\\\"-s: state = State(1, frozenset(23, 0)) We have a\",\n \"than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent\",\n \"else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for\",\n \"= card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner =\",\n \"Representing a \\\"Suit\\\" as an integer: n/a is -1 <-- used in a\",\n \"# Keep track of the opening suit. if player == 0: opening_suit =\",\n \"State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11, 20, 24, 38)\",\n \"Diamond 13 <-- 3rd card in round If 4th card is not 25,\",\n \"loses. We want to decrease the proportion with which we play 24. ba.add_loss(state,\",\n \"partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards)\",\n \"10000 STATS_PER = 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent:\",\n \"hand. Note: Ace is 12, 25, 38, 51 \\\"\\\"\\\" def count_points(hands): points =\",\n \"1.0) for opening_suit in range(4): for card_1 in range(52): for card_2 in range(card_1,\",\n \"as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags()\",\n \"their partner is guaranteed to win. \\\"\\\"\\\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played,\",\n \"max_val: max_val, max_idx = card, idx return max_idx \\\"\\\"\\\" This function determines the\",\n \"def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative\",\n \"= -1 # Each player plays a card in order starting from round_winner\",\n \"played so far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) #\",\n \"player) % 4 if player_idx == 2: # Agent plays if ba: agent_state\",\n \"is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played\",\n \"do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\"\",\n \"np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 # self.alpha = 0.9995 #\",\n \"play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER =\",\n \"\\\"\\\"\\\" round_winner = (d + 1) % 4 # the person to the\",\n \"def main(): start_time = datetime.datetime.now() hands = [] # TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN}\",\n \"Flag Ratios - Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\\\") with\",\n \"card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards)\",\n \"+ partner has played highest card, does agent play lowest card? do they\",\n \"opening suit of Diamonds. The agent is 3rd to play a card and\",\n \"-> 12 are Club 2 -> Club 14 Cards 13 -> 25 are\",\n \"24] valid_cards = np.array([i for i in range(suit * 13, (suit + 1)\",\n \"cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: #\",\n \"if player == 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get\",\n \"Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" + str(t) + \\\".csv\\\", 'w') as m:\",\n \"2 -> Heart 14 Cards 39 -> 51 are Spade 2 -> Spade\",\n \"= 1 since 20 has a smaller weight than 24. # index_into_valid_cards =\",\n \"Ratios - Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" + str(t) + \\\".csv\\\", 'w')\",\n \"should start the play return False, -1 \\\"\\\"\\\" This function counts the points\",\n \"plays a card in order starting from round_winner for player in range(4): card\",\n \"is 2 Spades is 3 Representing a \\\"State\\\" as an opening suit and\",\n \"np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta (want this to be\",\n \"cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if i in hands[player_idx]]) if\",\n \"for i in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for i\",\n \"this game # For each round for _ in range(13): cards_played = []\",\n \"points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS PERFORMANCE OF BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags:\",\n \"-1 <-- used in a \\\"State\\\" where no cards have been played yet.\",\n \"This function counts the points in each hand. Note: Ace is 12, 25,\",\n \"agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and\",\n \"52): for card_3 in range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]:\",\n \"agent wins. We want to incrase the proportion with which we play 24.\",\n \"= list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\" This function\",\n \"in range(iterations): hands = shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1]\",\n \"> 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if\",\n \"barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta (want this to be positive): {average_win_delta}\\\") print(f\\\"Average Red Flag\",\n \"* 13, (suit + 1) * 13) if i in cards_in_hand] if len(valid_cards)\",\n \"14 Cards 26 -> 38 are Heart 2 -> Heart 14 Cards 39\",\n \"+= 1 if (game + 1) % STATS_PER == 0: print(f\\\"{game + 1}\",\n \"round card_played = 24 # Diamond 13 <-- 3rd card in round If\",\n \"m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def main(): start_time = datetime.datetime.now() hands = []\",\n \"+ \\\"_Last_Game.txt\\\", 'w') as g: g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename + \\\".txt\\\",\",\n \"if the agent plays a higher card even though their partner is guaranteed\",\n \"positive): {average_win_delta}\\\") print(f\\\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag Ratios\",\n \"copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max] = -1 max =\",\n \"ba.add_loss(state, card_played) \\\"\\\"\\\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 *\",\n \"one. Representing the MDP with a Map from a \\\"State\\\" to an array\",\n \"{}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY FUNCTIONS \\\"\",\n \"highest weight. card_played = ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def play_card(self, state, cards_in_hand): # Following\",\n \"the declarer based on partnership with the most points. Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\"\",\n \"cards_played = [] agent_card_played = [-1, -1] agent_state = None agent_state_2 = None\",\n \"+ 1) * 13) if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards\",\n \"REPRESENTATIONS OF BRIDGE Representing a \\\"Card\\\" as an integer: Cards 0 -> 12\",\n \"% 13 == 12: p += 4 elif card % 13 == 11:\",\n \"13) if i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards)\",\n \"25 (Diamond 14), then the agent loses. We want to decrease the proportion\",\n \"card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0)\",\n \"NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\",\",\n \"length-52: We call this Map \\\"weights\\\". And the array of length-52 represets the\",\n \"for card_3 in range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]: state\",\n \"max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards):\",\n \"winner. \\\"\\\"\\\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards =\",\n \"> max_val: max_val, max_idx = card, idx return max_idx \\\"\\\"\\\" This function determines\",\n \"= [] agent_card_played = [-1, -1] agent_state = None agent_state_2 = None opening_suit\",\n \"round_winner = (d + 1) % 4 # the person to the right\",\n \"for hand in hands: p = 0 for card in hand: if card\",\n \"d = agent_declarer(hands) \\\"\\\"\\\" hands[0] = North's cards hands[1] = East's cards hands[2]\",\n \"NUM_GAMES_TEST = 10000 STATS_PER = 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\"\",\n \"counts the points in each hand. Note: Ace is 12, 25, 38, 51\",\n \"'w') as f: for state in self.weights: f.write(\\\"State: suit {} | cards played\",\n \"with highest weight. # index_into_valid_counts = 1 since 20 has a smaller weight\",\n \"None opening_suit = -1 # Each player plays a card in order starting\",\n \"round_winner == 0 or round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0])\",\n \"The agent must play a Diamond if it has Diamonds. In this example,\",\n \"= (round_winner + player) % 4 if player_idx == 2: # Agent plays\",\n \"= [] # TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\") ba = BridgeAgent() ba =\",\n \"26 -> 38 are Heart 2 -> Heart 14 Cards 39 -> 51\",\n \"1) * 13)) valid_cards = np.array([i for i in all_valid_cards if i in\",\n \"== 0 or round_winner == 2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if\",\n \"+ 1) % STATS_PER == 0: print(f\\\"{game + 1} / \\\", end=\\\"\\\", flush=True)\",\n \"an opening suit and frozenset of up to 3 \\\"Card\\\"-s: state = State(1,\",\n \"{average_win_delta}\\\") print(f\\\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag Ratios -\",\n \"-1 max = np.argmax(y) policy.append(max) count += 1 game_file = \\\"Bridge_\\\" + str(game\",\n \"24 If 4th card is 25 (Diamond 14), then the agent loses. We\",\n \"count = 0 with open(filename + \\\"_Last_Game.txt\\\", 'w') as g: g.write(\\\"Cards in Hand:\",\n \"Flag Ratios - Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" + str(t) + \\\".csv\\\",\",\n \"* 13) if i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return\",\n \"deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\" This\",\n \"+= 1 \\\"\\\"\\\" This function checks if the agent plays a higher card\",\n \"This function is used by non-agents who play randomly. \\\"\\\"\\\" def play_random_card(suit, cards_in_hand):\",\n \"as g: g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename + \\\".txt\\\", 'w') as f:\",\n \"* 13, (suit + 1) * 13) if i in cards_in_hand]) if len(valid_cards)\",\n \"12 King is 13 Ace is 14 Representing a \\\"Suit\\\" as an integer:\",\n \"for card_2 in range(card_1, 52): for card_3 in range(card_2, 52): for card_partner in\",\n \"points = count_points(hands) # determines the number of points in each hand #\",\n \"This function determines the declarer based on partnership with the most points. Return:\",\n \"function checks if the agent wins a round when there's three cards played\",\n \"= np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return\",\n \"Club 14 Cards 13 -> 25 are Diamond 2 -> Diamond 14 Cards\",\n \"NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random)\",\n \"state in self.weights: f.write(\\\"State: suit {} | cards played {} | partner's card\",\n \"have been played yet. Clubs is 0 Diamonds is 1 Hearts is 2\",\n \"to play whichever remaining card has the highest weight. The agent must play\",\n \"datetime.datetime.now() hands = [] # TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\") ba = BridgeAgent()\",\n \"each hand # agent's partnership has more points and agent is declarer if\",\n \"13 == 10: p += 2 elif card % 13 == 9: p\",\n \"the policy at the end of the data training phase. \\\"\\\"\\\" def write_policy(self,\",\n \"played + partner has played highest card, does agent play lowest card? do\",\n \"highest weight. # index_into_valid_counts = 1 since 20 has a smaller weight than\",\n \"agent choose to play whichever remaining card has the highest weight. The agent\",\n \"Map \\\"weights\\\". And the array of length-52 represets the proportion with which the\",\n \"1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\" This\",\n \"elif card % 13 == 9: p += 1 points.append(p) return points \\\"\\\"\\\"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\",\n \"function write the policy at the end of the data training phase. \\\"\\\"\\\"\",\n \"1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\" This function checks if the agent wins a\",\n \"CS 238 Final Project: Bridge RL Agent <NAME> & <NAME> \\\"\\\"\\\" import copy\",\n \"declarer if points[0] + points[2] > points[1] + points[3] and points[2] > points[0]:\",\n \"STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta (want\",\n \"# Diamond 13 <-- 3rd card in round If 4th card is not\",\n \"def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha ** self.game_num)\",\n \"1 NT bridge and outputs a winner. \\\"\\\"\\\" def play_game(game, hands, train=False, ba=None,\",\n \"{}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\\\"State: suit {} | cards\",\n \"agent plays a higher card even though their partner is guaranteed to win.\",\n \"states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card\",\n \"chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS, 1.0)\",\n \"self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\" This function checks for any red\",\n \"CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52 # Agent can choose any card to\",\n \"= None agent_state_2 = None opening_suit = -1 # Each player plays a\",\n \"yet. Clubs is 0 Diamonds is 1 Hearts is 2 Spades is 3\",\n \"State(1, frozenset(23, 0)) We have a Diamond 12 and Club 2 with an\",\n \"1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \\\"\\\"\\\" EXAMPLE state\",\n \"points[0]: return True, 2 # agent is not declarer and agent should start\",\n \"states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card\",\n \"open(filename + \\\".txt\\\", 'w') as f: for state in self.weights: f.write(\\\"State: suit {}\",\n \"an equal chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] =\",\n \"% 4 if player_idx == 2: # Agent plays if ba: agent_state =\",\n \"has the highest weight. The agent must play a Diamond if it has\",\n \"= list(range(suit * 13, (suit + 1) * 13)) valid_cards = np.array([i for\",\n \"the winner of the round. \\\"\\\"\\\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val\",\n \"self.ALL_RED_FLAG_TOTAL_COUNT[2] += 1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1\",\n \"max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] +=\",\n \"+= 1 points.append(p) return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS PERFORMANCE OF BRIDGE AGENT\",\n \"range(13): cards_played = [] agent_card_played = [-1, -1] agent_state = None agent_state_2 =\",\n \"4, 8, 11, 20, 24, 38) The agent choose to play whichever remaining\",\n \"Cards 0 -> 12 are Club 2 -> Club 14 Cards 13 ->\",\n \"# Each player plays a card in order starting from round_winner for player\",\n \"state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i for i in range(suit\",\n \"13 -> 25 are Diamond 2 -> Diamond 14 Cards 26 -> 38\",\n \"# Choose the valid card with highest weight. # index_into_valid_counts = 1 since\",\n \"with which we play 24. ba.add_win(state, card_played) \\\"\\\"\\\" def add_win(self, state, card_played): self.weights[state][card_played]\",\n \"average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT)\",\n \"= -1 for idx, card in enumerate(cards_played): if suit * 13 <= card\",\n \"p += 3 elif card % 13 == 10: p += 2 elif\",\n \"where no cards have been played yet. Clubs is 0 Diamonds is 1\",\n \"In this example, agent will most likely play 24, which beats 23 <--\",\n \"a Map from a \\\"State\\\" to an array of length-52: We call this\",\n \"starts the game NS_Wins = 0 # used to count total wins in\",\n \"# Cumulative statistics on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0)\",\n \"3 Representing a \\\"State\\\" as an opening suit and frozenset of up to\",\n \"def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards = [i for\",\n \"than theirs. \\\"\\\"\\\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and\",\n \"def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'w')\",\n \"& <NAME> \\\"\\\"\\\" import copy import datetime import numpy as np import random\",\n \"have a Diamond 12 and Club 2 with an opening suit of Diamonds.\",\n \"partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in\",\n \"+ points[2] > points[1] + points[3] and points[2] > points[0]: return True, 2\",\n \"max in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count += 1\",\n \"beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY A\",\n \"hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif player_idx ==\",\n \"datetime import numpy as np import random from collections import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS\",\n \"must play a Diamond if it has Diamonds. In this example, agent will\",\n \"even though the highest card already played is higher than theirs. \\\"\\\"\\\" def\",\n \"Diamond 14 Cards 26 -> 38 are Heart 2 -> Heart 14 Cards\",\n \"self.game_num = 1 \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) # Diamond 12,\",\n \"Agent <NAME> & <NAME> \\\"\\\"\\\" import copy import datetime import numpy as np\",\n \"0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha = 0.9999995 #\",\n \"the highest weight. The agent must play a Diamond if it has Diamonds.\",\n \"y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max] = -1\",\n \"is declarer, they play their partner's cards if ba and declarer: agent_state_2 =\",\n \"far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards\",\n \"-> 38 are Heart 2 -> Heart 14 Cards 39 -> 51 are\",\n \"call this Map \\\"weights\\\". And the array of length-52 represets the proportion with\",\n \"1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] +=\",\n \"has the highest weight. card_played = ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def play_card(self, state, cards_in_hand):\",\n \"though their partner is guaranteed to win. \\\"\\\"\\\" def partner_win(self, valid_cards, agent_valid_cards, card,\",\n \"{}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\"\",\n \"EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11,\",\n \"\\\" \\\" PLAY A SINGLE GAME OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function\",\n \"-- we don't change the weights here print(f\\\"TESTING on {NUM_GAMES_TEST} games\\\") game_summary(ba, False,\",\n \"self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0,\",\n \"(sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random =\",\n \"agent is 3rd to play a card and must play a Diamond if\",\n \"beats 23 <-- hopefully 24 has the highest weight. card_played = ba.play_card(state, cards_in_hand)\",\n \"the play return False, -1 \\\"\\\"\\\" This function counts the points in each\",\n \"card is 25 (Diamond 14), then the agent loses. We want to decrease\",\n \"cards_in_hand): # Following the EXAMPLE: # suit = 1 suit = state.opening_suit #\",\n \"partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) count += 1\",\n \"0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) card_played\",\n \"np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function\",\n \"agent will most likely play 24, which beats 23 <-- hopefully 24 has\",\n \"BRIDGE Representing a \\\"Card\\\" as an integer: Cards 0 -> 12 are Club\",\n \"player_idx = (round_winner + player) % 4 if player_idx == 2: # Agent\",\n \"(NUM_GAMES_TRAIN - 1): policy = [] count = 0 for x in ba.weights:\",\n \"barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game +\",\n \"a \\\"State\\\" as an opening suit and frozenset of up to 3 \\\"Card\\\"-s:\",\n \"NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2,\",\n \"1 if (game + 1) % STATS_PER == 0: print(f\\\"{game + 1} /\",\n \"card_3 in range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]: state =\",\n \"# Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4\",\n \"To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\\\"State: suit {}\",\n \"the agent plays a higher card even though their partner is guaranteed to\",\n \"in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\" This function\",\n \"\\\" TRACKS PERFORMANCE OF BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS\",\n \"ba = game_summary(ba, True) # TESTING -- we don't change the weights here\",\n \"not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card <\",\n \"\\\"\\\"\\\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1 * self.alpha **\",\n \"max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1\",\n \"= 0 for card in hand: if card % 13 == 12: p\",\n \"barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) +\",\n \"a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] ==\",\n \"13) if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand #\",\n \"determines the winner of the round. \\\"\\\"\\\" def determine_round_winner(suit, cards_played): max_idx = -1\",\n \"and must play a Diamond if it has one. Representing the MDP with\",\n \"\\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random =\",\n \"1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\" This function checks if the agent plays a\",\n \"partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer, d = agent_declarer(hands) \\\"\\\"\\\" hands[0] =\",\n \"are Spade 2 -> Spade 14 Jack is 11 Queen is 12 King\",\n \"-> Spade 14 Jack is 11 Queen is 12 King is 13 Ace\",\n \"Choose the valid card with highest weight. # index_into_valid_counts = 1 since 20\",\n \"= barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'a') as k:\",\n \"policy, filename, states_accessed): count = 0 with open(filename + \\\"_Last_Game.txt\\\", 'w') as g:\",\n \"| partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state\",\n \"in [-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]), card_partner)\",\n \"\\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions deals random cards. \\\"\\\"\\\" deck = list(range(52)) def\",\n \"of the round. \\\"\\\"\\\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1\",\n \"\\\" \\\" UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions deals random cards. \\\"\\\"\\\"\",\n \"index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\"\",\n \"return False, -1 \\\"\\\"\\\" This function counts the points in each hand. Note:\",\n \"this Map \\\"weights\\\". And the array of length-52 represets the proportion with which\",\n \"= np.array([i for i in range(suit * 13, (suit + 1) * 13)\",\n \"theirs. \\\"\\\"\\\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards)\",\n \"+= 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\" This function checks if the agent plays\",\n \"+ 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0))\",\n \"\\\"\\\"\\\" This function checks if the agent plays their highest card even though\",\n \"cards_in_hand = set(0, 1, 4, 8, 11, 20, 24, 38) The agent choose\",\n \"\\\" UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions deals random cards. \\\"\\\"\\\" deck\",\n \"beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\"\",\n \"play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) #\",\n \"card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards\",\n \"(determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the BridgeAgent weights. # If\",\n \"8, 11, 20, 24, 38) The agent choose to play whichever remaining card\",\n \"play a Diamond if it has Diamonds. In this example, agent will most\",\n \"= (1, set(23, 0)), weights[state] will likely have very large values at indices\",\n \"play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards = [i for i\",\n \"self.highest_card(valid_cards, agent_valid_cards, card) # 3 cards played and agent has higher cards, does\",\n \"The agent is 3rd to play a card and must play a Diamond\",\n \"win. \\\"\\\"\\\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) == 3\",\n \"25, 38, 51 \\\"\\\"\\\" def count_points(hands): points = [] for hand in hands:\",\n \"if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the valid card with\",\n \"partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[1] += 1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1]\",\n \"the right of the declarer starts the game NS_Wins = 0 # used\",\n \"points in each hand # agent's partnership has more points and agent is\",\n \"if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ):\",\n \"shuffle_cards() NS_Wins[-1] += play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None,\",\n \"policy[count])) count += 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This\",\n \"in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if i in hands[player_idx]])\",\n \"player == 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the\",\n \"False, -1 \\\"\\\"\\\" This function counts the points in each hand. Note: Ace\",\n \"> 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1]\",\n \"agent is not declarer and agent should start the play return False, -1\",\n \"is 12, 25, 38, 51 \\\"\\\"\\\" def count_points(hands): points = [] for hand\",\n \"2: if ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins +=\",\n \"max = np.argmax(y) policy.append(max) count += 1 game_file = \\\"Bridge_\\\" + str(game +\",\n \"card has the highest weight. The agent must play a Diamond if it\",\n \"14), then the agent loses. We want to decrease the proportion with which\",\n \"suit == -1: return random.choice(cards_in_hand) valid_cards = [i for i in range(suit *\",\n \"write out policy if ba and game == (NUM_GAMES_TRAIN - 1): policy =\",\n \"each of the 52 cards given that it is at that state. In\",\n \"4th card is not 25, then the agent wins. We want to incrase\",\n \"# For each round for _ in range(13): cards_played = [] agent_card_played =\",\n \"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE SOME CONSTANTS\",\n \"played highest card, does agent play lowest card? do they beat their partner?\",\n \"weights[state] will likely have very large values at indices 24 and 25 since\",\n \"of Diamonds. The agent is 3rd to play a card and must play\",\n \"function plays 13 rounds of 1 NT bridge and outputs a winner. \\\"\\\"\\\"\",\n \"\\\" PLAY A SINGLE GAME OF BRIDGE \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function plays\",\n \"game, determine and write out policy if ba and game == (NUM_GAMES_TRAIN -\",\n \"+ str(t) + \\\".csv\\\", 'w') as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\"\",\n \"highest weight. The agent must play a Diamond if it has Diamonds. In\",\n \"indices 24 and 25 since a Diamond 13 and Diamond 14 will beat\",\n \"bridge and outputs a winner. \\\"\\\"\\\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards\",\n \"it play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards)\",\n \"\\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags()\",\n \"24 has the highest weight. card_played = ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def play_card(self, state,\",\n \"= 0.9995 # 10,000 # self.alpha = 0.99995 # 100,000 self.alpha = 0.999995\",\n \"0)), weights[state] will likely have very large values at indices 24 and 25\",\n \"10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL AGENT \\\"\",\n \"a Diamond 12 and Club 2 with an opening suit of Diamonds. The\",\n \"2 -> Spade 14 Jack is 11 Queen is 12 King is 13\",\n \"states_accessed): count = 0 with open(filename + \\\"_Last_Game.txt\\\", 'w') as g: g.write(\\\"Cards in\",\n \"# Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the\",\n \"4 if player_idx == 2: # Agent plays if ba: agent_state = State(opening_suit,\",\n \"= np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 # self.alpha = 0.9995\",\n \"determines the declarer based on partnership with the most points. Return: (agent_is_declarer, declarer_idx)\",\n \"51 are Spade 2 -> Spade 14 Jack is 11 Queen is 12\",\n \"card_partner in [-1, card_1, card_2, card_3]: state = State( opening_suit, frozenset([card_1, card_2, card_3]),\",\n \"or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played\",\n \"a Diamond if it has one. Representing the MDP with a Map from\",\n \"25 since a Diamond 13 and Diamond 14 will beat the Diamond 12.\",\n \"higher card than what's been played. \\\"\\\"\\\" def higher_card(self, valid_cards, agent_valid_cards, card, cards_played,\",\n \"range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]: state = State( opening_suit,\",\n \"9: p += 1 points.append(p) return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS PERFORMANCE OF\",\n \"\\\"State\\\" where no cards have been played yet. Clubs is 0 Diamonds is\",\n \"the proportion with which the agent should play each of the 52 cards\",\n \"represets the proportion with which the agent should play each of the 52\",\n \"Delta (want this to be positive): {average_win_delta}\\\") print(f\\\"Average Red Flag Ratios - Agent:\",\n \"an opening suit of Diamonds. The agent is 3rd to play a card\",\n \"the EXAMPLE: # suit = 1 suit = state.opening_suit # valid_cards = [20,\",\n \"1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\" This function checks for any red flags based\",\n \"card) # 3 cards played and agent has higher cards, does it play\",\n \"which beats 23 <-- hopefully 24 has the highest weight. card_played = ba.play_card(state,\",\n \"# 3 cards played + partner has played highest card, does agent play\",\n \"card else: # Random bot plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track\",\n \"f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative statistics on red flags for\",\n \"hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner)\",\n \"card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\" This function checks\",\n \"\\\"\\\"\\\" This function checks for any red flags based on what the agent\",\n \"card > max_val: max_val, max_idx = card, idx return max_idx \\\"\\\"\\\" This function\",\n \"random cards. \\\"\\\"\\\" deck = list(range(52)) def shuffle_cards(): random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39],\",\n \"suit == -1: return # highest card played so far is higher than\",\n \"= np.array([i for i in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i\",\n \"card, cards_played, partners_cards): if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(valid_cards)\",\n \"UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions deals random cards. \\\"\\\"\\\" deck =\",\n \"0: valid_cards = cards_in_hand # Choose the valid card with highest weight. #\",\n \"38 are Heart 2 -> Heart 14 Cards 39 -> 51 are Spade\",\n \"the MDP with a Map from a \\\"State\\\" to an array of length-52:\",\n \"= 1 suit = state.opening_suit # valid_cards = [20, 24] valid_cards = np.array([i\",\n \"for i in range(suit * 13, (suit + 1) * 13) if i\",\n \"state. In this example, with state = (1, set(23, 0)), weights[state] will likely\",\n \"3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in\",\n \"used to count total wins in agent partnership states_accessed = [] # records\",\n \"a card in order starting from round_winner for player in range(4): card =\",\n \"of the declarer starts the game NS_Wins = 0 # used to count\",\n \"* self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) card_played =\",\n \"played already and the agent has at least one higher card than what's\",\n \"for opening_suit in range(4): for card_1 in range(52): for card_2 in range(card_1, 52):\",\n \"game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" +\",\n \"card in hand: if card % 13 == 12: p += 4 elif\",\n \"on partnership with the most points. Return: (agent_is_declarer, declarer_idx) \\\"\\\"\\\" def agent_declarer(hands): points\",\n \"1 if card > max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\" This\",\n \"count = 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y)\",\n \"non-agents who play randomly. \\\"\\\"\\\" def play_random_card(suit, cards_in_hand): if suit == -1: return\",\n \"been updated for this game # For each round for _ in range(13):\",\n \"in order starting from round_winner for player in range(4): card = None player_idx\",\n \"hands[3] = West's cards \\\"\\\"\\\" round_winner = (d + 1) % 4 #\",\n \"on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta =\",\n \"np.array([i for i in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for\",\n \"else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot plays\",\n \"cards played + partner has played highest card, does agent play lowest card?\",\n \"Red Flag Ratios - Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" + str(t) +\",\n \"\\\"\\\"\\\" import copy import datetime import numpy as np import random from collections\",\n \"count total wins in agent partnership states_accessed = [] # records which states\",\n \"assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit\",\n \"in self.weights: f.write(\\\"State: suit {} | cards played {} | partner's card {}\\\\nBest\",\n \"13 == 11: p += 3 elif card % 13 == 10: p\",\n \"f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative statistics on red flags\",\n \"and points[2] > points[0]: return True, 2 # agent is not declarer and\",\n \"already and the agent has at least one higher card than what's been\",\n \"if suit * 13 <= card < (suit + 1) * 13 and\",\n \"state = State(1, frozenset(23, 0)) We have a Diamond 12 and Club 2\",\n \"25 are Diamond 2 -> Diamond 14 Cards 26 -> 38 are Heart\",\n \"1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative\",\n \"starting from round_winner for player in range(4): card = None player_idx = (round_winner\",\n \"length-52 represets the proportion with which the agent should play each of the\",\n \"agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] =\",\n \"% STATS_PER == 0: print(f\\\"{game + 1} / \\\", end=\\\"\\\", flush=True) rfv =\",\n \"plays 13 rounds of 1 NT bridge and outputs a winner. \\\"\\\"\\\" def\",\n \"# Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\" This function\",\n \"determine and write out policy if ba and game == (NUM_GAMES_TRAIN - 1):\",\n \"[] # records which states have been updated for this game # For\",\n \"This function determines the winner of the round. \\\"\\\"\\\" def determine_round_winner(suit, cards_played): max_idx\",\n \"if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state,\",\n \"Representing a \\\"Card\\\" as an integer: Cards 0 -> 12 are Club 2\",\n \"is 1 Hearts is 2 Spades is 3 Representing a \\\"State\\\" as an\",\n \"array of length-52 represets the proportion with which the agent should play each\",\n \"a Diamond 13 and Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State\",\n \"have very large values at indices 24 and 25 since a Diamond 13\",\n \"the end of the data training phase. \\\"\\\"\\\" def write_policy(self, cards_in_hand, policy, filename,\",\n \"def play_game(game, hands, train=False, ba=None, barf=None): partners_cards = copy.copy(hands[0]) agents_cards = copy.copy(hands[2]) declarer,\",\n \"the BridgeAgent weights. # If the BridgeAgent or N wins. if round_winner ==\",\n \"len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the valid card with highest\",\n \"If the BridgeAgent or N wins. if round_winner == 0 or round_winner ==\",\n \"card has an equal chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(),\",\n \"+= 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1])\",\n \"+ \\\".csv\\\", 'w') as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\")\",\n \"< (suit + 1) * 13 and card > max_val: max_val, max_idx =\",\n \"= State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit,\",\n \"+= 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions deals\",\n \"is guaranteed to win. \\\"\\\"\\\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if\",\n \"states_accessed = [] # records which states have been updated for this game\",\n \"valid_cards = [i for i in range(suit * 13, (suit + 1) *\",\n \"the proportion with which we play 24. ba.add_win(state, card_played) \\\"\\\"\\\" def add_win(self, state,\",\n \"1 if card < max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\" This\",\n \"filename, states_accessed): count = 0 with open(filename + \\\"_Last_Game.txt\\\", 'w') as g: g.write(\\\"Cards\",\n \"= [] count = 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x]) max\",\n \"declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card,\",\n \"choose to play whichever remaining card has the highest weight. The agent must\",\n \"1 \\\"\\\"\\\" This function checks if the agent plays a higher card even\",\n \"4 # the person to the right of the declarer starts the game\",\n \"ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE: # suit\",\n \"who play randomly. \\\"\\\"\\\" def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand)\",\n \"card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else: # Random bot plays card\",\n \"ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last game, determine and\",\n \"any red flags based on what the agent played. \\\"\\\"\\\" def assess_card_played(self, hands,\",\n \"agent_card_played = [-1, -1] agent_state = None agent_state_2 = None opening_suit = -1\",\n \"0)) We have a Diamond 12 and Club 2 with an opening suit\",\n \"\\\"\\\"\\\" This function determines the declarer based on partnership with the most points.\",\n \"11 Queen is 12 King is 13 Ace is 14 Representing a \\\"Suit\\\"\",\n \"\\\"\\\"\\\" This function is used by non-agents who play randomly. \\\"\\\"\\\" def play_random_card(suit,\",\n \"NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative statistics on red\",\n \"<-- hopefully 24 has the highest weight. card_played = ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def\",\n \"% 4 # the person to the right of the declarer starts the\",\n \"agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and train:\",\n \"len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2] +=\",\n \"> points[0]: return True, 2 # agent is not declarer and agent should\",\n \"Spades is 3 Representing a \\\"State\\\" as an opening suit and frozenset of\",\n \"it has one. Representing the MDP with a Map from a \\\"State\\\" to\",\n \"the agent played. \\\"\\\"\\\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards\",\n \"the agent wins a round when there's three cards played already and the\",\n \"policy if ba and game == (NUM_GAMES_TRAIN - 1): policy = [] count\",\n \"played and agent has higher cards, does it play highest card or highest\",\n \"\\\".csv\\\", 'w') as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf\",\n \"= ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE: #\",\n \"agent_valid_cards, card, cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY A SINGLE GAME OF BRIDGE\",\n \"\\\"\\\"\\\" def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards = [i\",\n \"== -1: return # highest card played so far is higher than agent's\",\n \"- 1): policy = [] count = 0 for x in ba.weights: y\",\n \"SOME CONSTANTS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52 # Agent can choose any card\",\n \"is used by non-agents who play randomly. \\\"\\\"\\\" def play_random_card(suit, cards_in_hand): if suit\",\n \"main(): start_time = datetime.datetime.now() hands = [] # TRAINING print(f\\\"TRAINING on {NUM_GAMES_TRAIN} games\\\")\",\n \"set(23, 0)) # Diamond 12, Club 2 <-- first 2 cards in round\",\n \"their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY A SINGLE\",\n \"0: print(f\\\"{game + 1} / \\\", end=\\\"\\\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random =\",\n \"0 # used to count total wins in agent partnership states_accessed = []\",\n \"3rd card in round If 4th card is not 25, then the agent\",\n \"[i for i in range(suit * 13, (suit + 1) * 13) if\",\n \"if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\" This function determines the\",\n \"valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\"\",\n \"self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\" This function checks if the agent wins a round\",\n \"self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\" This function checks for any red flags based on\",\n \"random from collections import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \\\"Card\\\" as\",\n \"24, which beats 23 <-- hopefully 24 has the highest weight. card_played =\",\n \"copy.copy(hands[2]) declarer, d = agent_declarer(hands) \\\"\\\"\\\" hands[0] = North's cards hands[1] = East's\",\n \"in enumerate(cards_played): if suit * 13 <= card < (suit + 1) *\",\n \"total wins in agent partnership states_accessed = [] # records which states have\",\n \"such that every card has an equal chance of being chosen. self.weights =\",\n \"12, Club 2 <-- first 2 cards in round card_played = 24 #\",\n \"card, cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY A SINGLE GAME OF BRIDGE \\\"\",\n \"hands[0] = North's cards hands[1] = East's cards hands[2] = Agent's cards hands[3]\",\n \"and outputs a winner. \\\"\\\"\\\" def play_game(game, hands, train=False, ba=None, barf=None): partners_cards =\",\n \"- NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\" f\\\"{rfv[2]},{rftc[2]},\\\" f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative statistics on\",\n \"\\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This functions deals random cards.\",\n \"Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE\",\n \"{}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\\\"State:\",\n \"* 13) if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand\",\n \"\\\"Suit\\\" as an integer: n/a is -1 <-- used in a \\\"State\\\" where\",\n \"(d + 1) % 4 # the person to the right of the\",\n \"policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\"\",\n \"2 with an opening suit of Diamonds. The agent is 3rd to play\",\n \"max = np.argmax(y) while max in x.cards_played: y[max] = -1 max = np.argmax(y)\",\n \"+ str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t,\",\n \"used by non-agents who play randomly. \\\"\\\"\\\" def play_random_card(suit, cards_in_hand): if suit ==\",\n \"card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\" This function checks\",\n \"hands[player_idx]) # Keep track of the opening suit. if player == 0: opening_suit\",\n \"\\\"_Game_Data_Avg_Train-\\\" + str(t) + \\\".csv\\\", 'w') as m: m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def\",\n \"proportion with which we play 24. ba.add_loss(state, card_played) \\\"\\\"\\\" def add_loss(self, state, card_played):\",\n \"Queen is 12 King is 13 Ace is 14 Representing a \\\"Suit\\\" as\",\n \"hands[1] = East's cards hands[2] = Agent's cards hands[3] = West's cards \\\"\\\"\\\"\",\n \"\\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS PERFORMANCE OF BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def\",\n \"STATS_PER = 1000 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def\",\n \"PERFORMANCE OF BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3)\",\n \"1) * 13 and card > max_val: max_val, max_idx = card, idx return\",\n \"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" NUM_ACTIONS = 52 # Agent can choose any card to play (only\",\n \"self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 # self.alpha =\",\n \"agent_declarer(hands): points = count_points(hands) # determines the number of points in each hand\",\n \"= (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random\",\n \"Cumulative statistics on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0)\",\n \"0: return random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\" This function determines the winner of the\",\n \"# self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \\\"\\\"\\\" EXAMPLE state =\",\n \"+= play_game(game=game, hands=copy.deepcopy(hands), train=True, ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num\",\n \"i in hands[player_idx]]) if suit == -1: return # highest card played so\",\n \"end_time = datetime.datetime.now() print(\\\"Runtime: \\\", end_time - start_time) # runtime if __name__ ==\",\n \"max_idx \\\"\\\"\\\" This function determines the declarer based on partnership with the most\",\n \"\\\"State\\\" as an opening suit and frozenset of up to 3 \\\"Card\\\"-s: state\",\n \"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function plays 13 rounds of 1 NT bridge and outputs\",\n \"the last game, determine and write out policy if ba and game ==\",\n \"if the agent plays their highest card even though the highest card already\",\n \"agent played. \\\"\\\"\\\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards =\",\n \"card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1)\",\n \"ba and train: ba.add_loss(agent_state, agent_card_played[0]) if declarer: ba.add_loss(agent_state_2, agent_card_played[1]) # for the last\",\n \"in all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards\",\n \"[-1, -1] agent_state = None agent_state_2 = None opening_suit = -1 # Each\",\n \"likely play 24, which beats 23 <-- hopefully 24 has the highest weight.\",\n \"10: p += 2 elif card % 13 == 9: p += 1\",\n \"hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game + 1) % STATS_PER ==\",\n \"(suit + 1) * 13 and card > max_val: max_val, max_idx = card,\",\n \"2: # Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card\",\n \"= np.argmax(y) policy.append(max) count += 1 game_file = \\\"Bridge_\\\" + str(game + 1)\",\n \"12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card']) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" DEFINE SOME\",\n \"return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\" This function is used by non-agents who\",\n \"card with highest weight. # index_into_valid_counts = 1 since 20 has a smaller\",\n \"== 3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] +=\",\n \"+= 3 elif card % 13 == 10: p += 2 elif card\",\n \"opening suit. if player == 0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card)\",\n \"agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card =\",\n \"is 25 (Diamond 14), then the agent loses. We want to decrease the\",\n \"23 <-- hopefully 24 has the highest weight. card_played = ba.play_card(state, cards_in_hand) \\\"\\\"\\\"\",\n \"plays card = play_random_card(opening_suit, hands[player_idx]) # Keep track of the opening suit. if\",\n \"a \\\"Suit\\\" as an integer: n/a is -1 <-- used in a \\\"State\\\"\",\n \"integer: n/a is -1 <-- used in a \\\"State\\\" where no cards have\",\n \"ba=ba, barf=barf) NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game\",\n \"states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t)\",\n \"highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0]\",\n \"= \\\"Bridge_\\\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def\",\n \"str(t) + \\\".csv\\\", 'w') as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\" \\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\"\",\n \"+ player) % 4 if player_idx == 2: # Agent plays if ba:\",\n \"will likely have very large values at indices 24 and 25 since a\",\n \"1) % STATS_PER == 0: print(f\\\"{game + 1} / \\\", end=\\\"\\\", flush=True) rfv\",\n \"24. ba.add_loss(state, card_played) \\\"\\\"\\\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1 + 0.1\",\n \"np.argmax(y) policy.append(max) count += 1 game_file = \\\"Bridge_\\\" + str(game + 1) ba.write_policy(agents_cards,\",\n \"iterations=NUM_GAMES_TEST) end_time = datetime.datetime.now() print(\\\"Runtime: \\\", end_time - start_time) # runtime if __name__\",\n \"= West's cards \\\"\\\"\\\" round_winner = (d + 1) % 4 # the\",\n \"function checks if the agent plays a higher card even though their partner\",\n \"self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" PLAY A SINGLE GAME OF\",\n \"In this example, with state = (1, set(23, 0)), weights[state] will likely have\",\n \"ba.add_win(state, card_played) \\\"\\\"\\\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 *\",\n \"= copy.copy(hands[2]) declarer, d = agent_declarer(hands) \\\"\\\"\\\" hands[0] = North's cards hands[1] =\",\n \"for _ in range(13): cards_played = [] agent_card_played = [-1, -1] agent_state =\",\n \"of points in each hand # agent's partnership has more points and agent\",\n \"is 13 Ace is 14 Representing a \\\"Suit\\\" as an integer: n/a is\",\n \"# If the BridgeAgent or N wins. if round_winner == 0 or round_winner\",\n \"West's cards \\\"\\\"\\\" round_winner = (d + 1) % 4 # the person\",\n \"card even though their partner is guaranteed to win. \\\"\\\"\\\" def partner_win(self, valid_cards,\",\n \"of the 52 cards given that it is at that state. In this\",\n \"t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'w') as k:\",\n \"Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename + \\\".txt\\\", 'w') as f: for state in self.weights:\",\n \"0.9999995 # 5,000,000 self.game_num = 1 \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0))\",\n \"average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta (want this\",\n \"if card == max(agent_valid_cards): self.RED_FLAG_VIOLATIONS[0] += 1 self.ALL_RED_FLAG_VIOLATIONS[0] += 1 \\\"\\\"\\\" This function\",\n \"the round. \\\"\\\"\\\" def determine_round_winner(suit, cards_played): max_idx = -1 max_val = -1 for\",\n \"0)) card_played = 24 If 4th card is 25 (Diamond 14), then the\",\n \"= North's cards hands[1] = East's cards hands[2] = Agent's cards hands[3] =\",\n \"\\\"\\\"\\\" CS 238 Final Project: Bridge RL Agent <NAME> & <NAME> \\\"\\\"\\\" import\",\n \"if (game + 1) % STATS_PER == 0: print(f\\\"{game + 1} / \\\",\",\n \"card to play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000\",\n \"card): if len(agent_valid_cards) > 1 and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0]\",\n \"<NAME> \\\"\\\"\\\" import copy import datetime import numpy as np import random from\",\n \"there's three cards played already and the agent has at least one higher\",\n \"= [] for hand in hands: p = 0 for card in hand:\",\n \"card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards)\",\n \"played {} | partner's card {}\\\\nBest Card To Play: {}\\\\n\\\\n\\\".format(state.opening_suit, state.cards_played, state.partners_card, policy[count]))\",\n \"True, 2 # agent is not declarer and agent should start the play\",\n \"in range(card_2, 52): for card_partner in [-1, card_1, card_2, card_3]: state = State(\",\n \"# for the last game, determine and write out policy if ba and\",\n \"cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\" This function determines\",\n \"used in a \\\"State\\\" where no cards have been played yet. Clubs is\",\n \"East's cards hands[2] = Agent's cards hands[3] = West's cards \\\"\\\"\\\" round_winner =\",\n \"1 points.append(p) return points \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" TRACKS PERFORMANCE OF BRIDGE AGENT \\\"\",\n \"deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\" This function is used by non-agents who play randomly.\",\n \"clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\" This function checks if the\",\n \"state in states_accessed: g.write(\\\"State: suit {} | cards played {} | partner's card\",\n \"g.write(\\\"State: suit {} | cards played {} | partner's card {}\\\\nBest Card To\",\n \"and game == (NUM_GAMES_TRAIN - 1): policy = [] count = 0 for\",\n \"1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win\",\n \"North's cards hands[1] = East's cards hands[2] = Agent's cards hands[3] = West's\",\n \"deck[39:52]] \\\"\\\"\\\" This function is used by non-agents who play randomly. \\\"\\\"\\\" def\",\n \"self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function write the\",\n \"< max(valid_cards): self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\" This function checks if\",\n \"barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game in range(iterations):\",\n \"+ \\\"_Game_Data_Train-\\\" + str(t) + \\\".csv\\\", 'w') as k: k.write(\\\"game,\\\" \\\"agent_wins,random_wins,diff_wins,\\\" \\\"agent_rfv_a,agent_rftc_a,\\\" \\\"agent_rfv_b,agent_rftc_b,\\\"\",\n \"winning card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the\",\n \"= -1 max_val = -1 for idx, card in enumerate(cards_played): if suit *\",\n \"TRACKS PERFORMANCE OF BRIDGE AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS =\",\n \"card_played) \\\"\\\"\\\" def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha\",\n \"and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands,\",\n \"= set(0, 1, 4, 8, 11, 20, 24, 38) The agent choose to\",\n \"no cards have been played yet. Clubs is 0 Diamonds is 1 Hearts\",\n \"= copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played: y[max] = -1 max\",\n \"has an equal chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)]\",\n \"in range(card_1, 52): for card_3 in range(card_2, 52): for card_partner in [-1, card_1,\",\n \"self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand = set(0, 1, 4,\",\n \"all_valid_cards if i in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if\",\n \"NS_Wins_random[-1] += play_game(game=game, hands=hands, ba=None, barf=barf_random) ba.game_num += 1 if (game + 1)\",\n \"weight. The agent must play a Diamond if it has Diamonds. In this\",\n \"random.choice(valid_cards) \\\"\\\"\\\" This function determines the winner of the round. \\\"\\\"\\\" def determine_round_winner(suit,\",\n \"+ 1) * 13)) valid_cards = np.array([i for i in all_valid_cards if i\",\n \"\\\"\\\"\\\" def count_points(hands): points = [] for hand in hands: p = 0\",\n \"-> Heart 14 Cards 39 -> 51 are Spade 2 -> Spade 14\",\n \"1 Hearts is 2 Spades is 3 Representing a \\\"State\\\" as an opening\",\n \"0: # if agent is declarer, they play their partner's cards if ba\",\n \"== 11: p += 3 elif card % 13 == 10: p +=\",\n \"% 13 == 11: p += 3 elif card % 13 == 10:\",\n \"\\\"State\\\" to an array of length-52: We call this Map \\\"weights\\\". And the\",\n \"if i in cards_played]) agent_valid_cards = np.array([i for i in all_valid_cards if i\",\n \"/ ((len(NS_Wins) - 1) * STATS_PER) average_rf_ratios_agent = np.divide(barf.ALL_RED_FLAG_VIOLATIONS, barf.ALL_RED_FLAG_TOTAL_COUNT) average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS,\",\n \"= State(1, set(23, 0)) card_played = 24 If 4th card is 25 (Diamond\",\n \"agent_state_2 = None opening_suit = -1 # Each player plays a card in\",\n \"the person to the right of the declarer starts the game NS_Wins =\",\n \"in each hand # agent's partnership has more points and agent is declarer\",\n \"agent_declarer(hands) \\\"\\\"\\\" hands[0] = North's cards hands[1] = East's cards hands[2] = Agent's\",\n \"= ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit,\",\n \"= BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random = [0] for game in range(iterations): hands\",\n \"in a \\\"State\\\" where no cards have been played yet. Clubs is 0\",\n \"been played yet. Clubs is 0 Diamonds is 1 Hearts is 2 Spades\",\n \"and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if\",\n \"example, agent will most likely play 24, which beats 23 <-- hopefully 24\",\n \"Cards 26 -> 38 are Heart 2 -> Heart 14 Cards 39 ->\",\n \"plays a higher card even though their partner is guaranteed to win. \\\"\\\"\\\"\",\n \"return random.choice(valid_cards) \\\"\\\"\\\" This function determines the winner of the round. \\\"\\\"\\\" def\",\n \"as np import random from collections import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing\",\n \"True) # TESTING -- we don't change the weights here print(f\\\"TESTING on {NUM_GAMES_TEST}\",\n \"average_rf_ratios_random = np.divide(barf_random.ALL_RED_FLAG_VIOLATIONS, barf_random.ALL_RED_FLAG_TOTAL_COUNT) print(f\\\"Average Win Delta (want this to be positive): {average_win_delta}\\\")\",\n \"ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba and train: ba.add_loss(agent_state, agent_card_played[0]) if\",\n \"0.999995 # 1,000,000 # self.alpha = 0.9999995 # 5,000,000 self.game_num = 1 \\\"\\\"\\\"\",\n \"cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card =\",\n \"their partner's cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2)\",\n \"Heart 14 Cards 39 -> 51 are Spade 2 -> Spade 14 Jack\",\n \"hands[2] = Agent's cards hands[3] = West's cards \\\"\\\"\\\" round_winner = (d +\",\n \"Final Project: Bridge RL Agent <NAME> & <NAME> \\\"\\\"\\\" import copy import datetime\",\n \"Diamonds. In this example, agent will most likely play 24, which beats 23\",\n \"least one higher card than what's been played. \\\"\\\"\\\" def higher_card(self, valid_cards, agent_valid_cards,\",\n \"and Club 2 with an opening suit of Diamonds. The agent is 3rd\",\n \"card_played = ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def play_card(self, state, cards_in_hand): # Following the EXAMPLE:\",\n \"\\\"Card\\\"-s: state = State(1, frozenset(23, 0)) We have a Diamond 12 and Club\",\n \"and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[2]\",\n \"ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit,\",\n \"cards have been played yet. Clubs is 0 Diamonds is 1 Hearts is\",\n \"= [i for i in range(suit * 13, (suit + 1) * 13)\",\n \"frozenset(23, 0)) We have a Diamond 12 and Club 2 with an opening\",\n \"np.array([i for i in all_valid_cards if i in hands[player_idx]]) if suit == -1:\",\n \"hopefully 24 has the highest weight. card_played = ba.play_card(state, cards_in_hand) \\\"\\\"\\\" def play_card(self,\",\n \"are Diamond 2 -> Diamond 14 Cards 26 -> 38 are Heart 2\",\n \"agent_valid_cards, card) # 3 cards played and agent has higher cards, does it\",\n \"2 elif card % 13 == 9: p += 1 points.append(p) return points\",\n \"12: p += 4 elif card % 13 == 11: p += 3\",\n \"random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\" This function determines the winner of the round. \\\"\\\"\\\"\",\n \"# Agent plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card =\",\n \"play 24, which beats 23 <-- hopefully 24 has the highest weight. card_played\",\n \"a round when there's three cards played already and the agent has at\",\n \"up to 3 \\\"Card\\\"-s: state = State(1, frozenset(23, 0)) We have a Diamond\",\n \"[0] NS_Wins_random = [0] for game in range(iterations): hands = shuffle_cards() NS_Wins[-1] +=\",\n \"equal chance of being chosen. self.weights = {} self.weights[State(-1, frozenset(), -1)] = np.full(NUM_ACTIONS,\",\n \"-> 51 are Spade 2 -> Spade 14 Jack is 11 Queen is\",\n \"player_idx, partners_cards) elif player_idx == 0: # if agent is declarer, they play\",\n \"== 0: valid_cards = cards_in_hand # Choose the valid card with highest weight.\",\n \"2 -> Diamond 14 Cards 26 -> 38 are Heart 2 -> Heart\",\n \"= 24 If 4th card is 25 (Diamond 14), then the agent loses.\",\n \"-1] agent_state = None agent_state_2 = None opening_suit = -1 # Each player\",\n \"g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename + \\\".txt\\\", 'w') as f: for state\",\n \"= State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played,\",\n \"plays if ba: agent_state = State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx])\",\n \"train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else: if ba\",\n \"== 0: # if agent is declarer, they play their partner's cards if\",\n \"\\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) # Diamond 12, Club 2 <--\",\n \"i in cards_in_hand] if len(valid_cards) == 0: return random.choice(cards_in_hand) return random.choice(valid_cards) \\\"\\\"\\\" This\",\n \"smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards = np.random.choice(np.flatnonzero(self.weights[state][valid_cards] == self.weights[state][valid_cards].max()))\",\n \"+= 1 \\\"\\\"\\\" This function checks if the agent wins a round when\",\n \"while max in x.cards_played: y[max] = -1 max = np.argmax(y) policy.append(max) count +=\",\n \"opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card else:\",\n \"randomly. \\\"\\\"\\\" def play_random_card(suit, cards_in_hand): if suit == -1: return random.choice(cards_in_hand) valid_cards =\",\n \"the agent has at least one higher card than what's been played. \\\"\\\"\\\"\",\n \"in range(13): cards_played = [] agent_card_played = [-1, -1] agent_state = None agent_state_2\",\n \"Diamond 12, Club 2 <-- first 2 cards in round card_played = 24\",\n \"state.partners_card, policy[count])) count += 1 \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \\\" \\\" UTILITY FUNCTIONS \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\"\",\n \"with an opening suit of Diamonds. The agent is 3rd to play a\",\n \"52 # Agent can choose any card to play (only some are valid).\",\n \"set(0, 1, 4, 8, 11, 20, 24, 38) The agent choose to play\",\n \"state.cards_played, state.partners_card, policy[count])) if state in states_accessed: g.write(\\\"State: suit {} | cards played\",\n \"for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) / ((len(NS_Wins)\",\n \"card. round_winner = (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the BridgeAgent\",\n \"state = State(1, set(23, 0)) # Diamond 12, Club 2 <-- first 2\",\n \"flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags() NS_Wins.append(0) NS_Wins_random.append(0) average_win_delta = (sum(NS_Wins)-sum(NS_Wins_random)) /\",\n \"self.higher_card(valid_cards, agent_valid_cards, card, cards_played, partners_cards) # 3 cards played + partner has played\",\n \"\\\"agent_rfv_c,agent_rftc_c,\\\" \\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0]\",\n \"MDP with a Map from a \\\"State\\\" to an array of length-52: We\",\n \"f\\\"{rfv_random[0]},{rftc_random[0]},\\\" f\\\"{rfv_random[1]},{rftc_random[1]},\\\" f\\\"{rfv_random[2]},{rftc_random[2]},\\\" f\\\"\\\\n\\\") # Cumulative statistics on red flags for every STATS_PER\",\n \"if (len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and\",\n \"played. \\\"\\\"\\\" def assess_card_played(self, hands, card, suit, cards_played, player_idx, partners_cards): all_valid_cards = list(range(suit\",\n \"and the agent has at least one higher card than what's been played.\",\n \"card, opening_suit, cards_played, player_idx, partners_cards) else: card = play_random_card(opening_suit, hands[player_idx]) agent_card_played[1] = card\",\n \"print(f\\\"{game + 1} / \\\", end=\\\"\\\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS\",\n \"points[3] and points[2] > points[0]: return True, 2 # agent is not declarer\",\n \"20, 24, 38) The agent choose to play whichever remaining card has the\",\n \"must play a Diamond if it has one. Representing the MDP with a\",\n \"as an opening suit and frozenset of up to 3 \\\"Card\\\"-s: state =\",\n \"= np.zeros(3) # Cumulative def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\"\",\n \"end=\\\"\\\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random =\",\n \"a higher card even though their partner is guaranteed to win. \\\"\\\"\\\" def\",\n \"Adjust the BridgeAgent weights. # If the BridgeAgent or N wins. if round_winner\",\n \"a Diamond if it has Diamonds. In this example, agent will most likely\",\n \"self.alpha = 0.997 # 1,000 # self.alpha = 0.9995 # 10,000 # self.alpha\",\n \"Ratios - Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN)\",\n \"valid_cards = np.array([i for i in range(suit * 13, (suit + 1) *\",\n \"round_winner) % 4 # Adjust the BridgeAgent weights. # If the BridgeAgent or\",\n \"an integer: Cards 0 -> 12 are Club 2 -> Club 14 Cards\",\n \"State(opening_suit, frozenset(cards_played), agent_card_played[1]) states_accessed.append(agent_state) card = ba.play_card(agent_state, hands[player_idx]) else: card = play_random_card(opening_suit, hands[player_idx])\",\n \"1) ba.write_policy(agents_cards, policy, game_file, states_accessed) return NS_Wins def game_summary(ba, t, iterations=NUM_GAMES_TRAIN): with open(str(NUM_GAMES_TRAIN)\",\n \"points[0] + points[2] > points[1] + points[3] and points[2] > points[0]: return True,\",\n \"self.RED_FLAG_VIOLATIONS[1] += 1 self.ALL_RED_FLAG_VIOLATIONS[1] += 1 \\\"\\\"\\\" This function checks if the agent\",\n \"ba def main(): start_time = datetime.datetime.now() hands = [] # TRAINING print(f\\\"TRAINING on\",\n \"game # For each round for _ in range(13): cards_played = [] agent_card_played\",\n \"\\\"_Last_Game.txt\\\", 'w') as g: g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename + \\\".txt\\\", 'w')\",\n \"and max(valid_cards) > max(agent_valid_cards): self.RED_FLAG_TOTAL_COUNT[0] += 1 self.ALL_RED_FLAG_TOTAL_COUNT[0] += 1 if card ==\",\n \"f.write(\\\"State: suit {} | cards played {} | partner's card {}\\\\nBest Card To\",\n \"to 3 \\\"Card\\\"-s: state = State(1, frozenset(23, 0)) We have a Diamond 12\",\n \"Diamond 14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State', ['opening_suit', 'cards_played',\",\n \"f\\\"\\\\n\\\") # Cumulative statistics on red flags for every STATS_PER games. barf.clear_red_flags() barf_random.clear_red_flags()\",\n \"index_into_valid_counts = 1 since 20 has a smaller weight than 24. # index_into_valid_cards\",\n \"0)) cards_in_hand = set(0, 1, 4, 8, 11, 20, 24, 38) The agent\",\n \"/= (1 + 0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1,\",\n \"and agent is declarer if points[0] + points[2] > points[1] + points[3] and\",\n \"import numpy as np import random from collections import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF\",\n \"# self.alpha = 0.99995 # 100,000 self.alpha = 0.999995 # 1,000,000 # self.alpha\",\n \"card already played is higher than theirs. \\\"\\\"\\\" def highest_card(self, valid_cards, agent_valid_cards, card):\",\n \"idx, card in enumerate(cards_played): if suit * 13 <= card < (suit +\",\n \"def count_points(hands): points = [] for hand in hands: p = 0 for\",\n \"the agent should play each of the 52 cards given that it is\",\n \"of 1 NT bridge and outputs a winner. \\\"\\\"\\\" def play_game(game, hands, train=False,\",\n \"14 will beat the Diamond 12. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" State = namedtuple('State', ['opening_suit', 'cards_played', 'partners_card'])\",\n \"state = State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11, 20,\",\n \"states_accessed: g.write(\\\"State: suit {} | cards played {} | partner's card {}\\\\nBest Card\",\n \"self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS = np.zeros(3) # Cumulative self.ALL_RED_FLAG_TOTAL_COUNT =\",\n \"games\\\") ba = BridgeAgent() ba = game_summary(ba, True) # TESTING -- we don't\",\n \"has one. Representing the MDP with a Map from a \\\"State\\\" to an\",\n \"all_valid_cards = list(range(suit * 13, (suit + 1) * 13)) valid_cards = np.array([i\",\n \"records which states have been updated for this game # For each round\",\n \"1, 4, 8, 11, 20, 24, 38) The agent choose to play whichever\",\n \"3 and len(agent_valid_cards) > 1 and max(valid_cards) in partners_cards ): self.RED_FLAG_TOTAL_COUNT[2] += 1\",\n \"does agent play lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card,\",\n \"with open(filename + \\\"_Last_Game.txt\\\", 'w') as g: g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename\",\n \"array of length-52: We call this Map \\\"weights\\\". And the array of length-52\",\n \"We want to decrease the proportion with which we play 24. ba.add_loss(state, card_played)\",\n \"+= 1 game_file = \\\"Bridge_\\\" + str(game + 1) ba.write_policy(agents_cards, policy, game_file, states_accessed)\",\n \"print(f\\\"Average Red Flag Ratios - Agent: {average_rf_ratios_agent}\\\") print(f\\\"Average Red Flag Ratios - Random:\",\n \"collections import namedtuple \\\"\\\"\\\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' REPRESENTATIONS OF BRIDGE Representing a \\\"Card\\\" as an integer:\",\n \"agent_valid_cards = np.array([i for i in all_valid_cards if i in hands[player_idx]]) if suit\",\n \"0.1 * self.alpha ** self.game_num) \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) cards_in_hand\",\n \"<-- first 2 cards in round card_played = 24 # Diamond 13 <--\",\n \"x in ba.weights: y = copy.deepcopy(ba.weights[x]) max = np.argmax(y) while max in x.cards_played:\",\n \"of length-52 represets the proportion with which the agent should play each of\",\n \"cards, does it play highest card or highest necessary card? self.higher_card(valid_cards, agent_valid_cards, card,\",\n \"frozenset of up to 3 \\\"Card\\\"-s: state = State(1, frozenset(23, 0)) We have\",\n \"most likely play 24, which beats 23 <-- hopefully 24 has the highest\",\n \"= play_random_card(opening_suit, hands[player_idx]) agent_card_played[0] = card barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx, partners_cards) elif\",\n \"def clear_red_flags(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\" This function checks if\",\n \"wins a round when there's three cards played already and the agent has\",\n \"= [20, 24] valid_cards = np.array([i for i in range(suit * 13, (suit\",\n \"\\\"random_rfv_a,random_rftc_a,\\\" \\\"random_rfv_b,random_rftc_b,\\\" \\\"random_rfv_c,random_rftc_c\\\\n\\\") barf = BridgeAgentRedFlags() barf_random = BridgeAgentRedFlags() NS_Wins = [0] NS_Wins_random\",\n \"print(f\\\"Average Red Flag Ratios - Random: {average_rf_ratios_random}\\\") with open(str(NUM_GAMES_TRAIN) + \\\"_Game_Data_Avg_Train-\\\" + str(t)\",\n \"def add_win(self, state, card_played): self.weights[state][card_played] *= (1 + 0.1 * self.alpha ** self.game_num)\",\n \"\\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" \\\"\\\"\\\" This function plays 13 rounds of 1 NT bridge and\",\n \"policy = [] count = 0 for x in ba.weights: y = copy.deepcopy(ba.weights[x])\",\n \"str(t) + \\\".csv\\\", 'a') as k: k.write( f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\"\",\n \"for idx, card in enumerate(cards_played): if suit * 13 <= card < (suit\",\n \"m.write(f\\\"avg_win_delta,avg_rf_agent,avg_rf_random\\\\n\\\" f\\\"{average_win_delta},{average_rf_ratios_agent},{average_rf_ratios_random}\\\\n\\\") return ba def main(): start_time = datetime.datetime.now() hands = [] #\",\n \"in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename + \\\".txt\\\", 'w') as f: for state in\",\n \"we play 24. ba.add_loss(state, card_played) \\\"\\\"\\\" def add_loss(self, state, card_played): self.weights[state][card_played] /= (1\",\n \"valid_cards = [20, 24] valid_cards = np.array([i for i in range(suit * 13,\",\n \"* 13 and card > max_val: max_val, max_idx = card, idx return max_idx\",\n \"game NS_Wins = 0 # used to count total wins in agent partnership\",\n \"agent_valid_cards, card, cards_played, partners_cards) # 3 cards played + partner has played highest\",\n \"f: for state in self.weights: f.write(\\\"State: suit {} | cards played {} |\",\n \"'w') as g: g.write(\\\"Cards in Hand: {}\\\\n\\\\n\\\".format(cards_in_hand)) with open(filename + \\\".txt\\\", 'w') as\",\n \"\\\"\\\"\\\" def agent_declarer(hands): points = count_points(hands) # determines the number of points in\",\n \"ba and train: ba.add_win(agent_state, agent_card_played[0]) if declarer: ba.add_win(agent_state_2, agent_card_played[1]) NS_Wins += 1 else:\",\n \"import copy import datetime import numpy as np import random from collections import\",\n \"== self.weights[state][valid_cards].max())) # returns valid_cards[1] = 24 return valid_cards[index_into_valid_cards] \\\"\\\"\\\" This function write\",\n \"to decrease the proportion with which we play 24. ba.add_loss(state, card_played) \\\"\\\"\\\" def\",\n \"card played so far is higher than agent's highest card self.highest_card(valid_cards, agent_valid_cards, card)\",\n \"and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards\",\n \"(len(cards_played) == 3 and len(agent_valid_cards) > 1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards)\",\n \"is 11 Queen is 12 King is 13 Ace is 14 Representing a\",\n \"if i in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose\",\n \"> max(valid_cards): self.RED_FLAG_VIOLATIONS[2] += 1 self.ALL_RED_FLAG_VIOLATIONS[2] += 1 \\\"\\\"\\\" This function checks for\",\n \"= (determine_round_winner(opening_suit, cards_played) + round_winner) % 4 # Adjust the BridgeAgent weights. #\",\n \"max_val = -1 for idx, card in enumerate(cards_played): if suit * 13 <=\",\n \"RL AGENT \\\" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgent: def __init__(self): # We initialize all weights\",\n \"play lowest card? do they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards)\",\n \"hands[player_idx]]) if suit == -1: return # highest card played so far is\",\n \"State(1, set(23, 0)) card_played = 24 If 4th card is 25 (Diamond 14),\",\n \"to win. \\\"\\\"\\\" def partner_win(self, valid_cards, agent_valid_cards, card, cards_played, partners_cards): if (len(cards_played) ==\",\n \"random.shuffle(deck) return [deck[0:13], deck[13:26], deck[26:39], deck[39:52]] \\\"\\\"\\\" This function is used by non-agents\",\n \"since 20 has a smaller weight than 24. # index_into_valid_cards = np.argmax(self.weights[state][valid_cards]) index_into_valid_cards\",\n \"a \\\"State\\\" to an array of length-52: We call this Map \\\"weights\\\". And\",\n \"EXAMPLE: # suit = 1 suit = state.opening_suit # valid_cards = [20, 24]\",\n \"has higher cards, does it play highest card or highest necessary card? self.higher_card(valid_cards,\",\n \"3 \\\"Card\\\"-s: state = State(1, frozenset(23, 0)) We have a Diamond 12 and\",\n \"cards_in_hand, policy, filename, states_accessed): count = 0 with open(filename + \\\"_Last_Game.txt\\\", 'w') as\",\n \"13, (suit + 1) * 13)) valid_cards = np.array([i for i in all_valid_cards\",\n \"Diamond if it has Diamonds. In this example, agent will most likely play\",\n \"i in cards_in_hand]) if len(valid_cards) == 0: valid_cards = cards_in_hand # Choose the\",\n \"1 and max(agent_valid_cards) > max(valid_cards) and max(valid_cards) not in partners_cards ): self.RED_FLAG_TOTAL_COUNT[1] +=\",\n \"= barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random = barf_random.RED_FLAG_TOTAL_COUNT with open(str(NUM_GAMES_TRAIN)\",\n \"cards_played, partners_cards) # 3 cards played + partner has played highest card, does\",\n \"= 1 \\\"\\\"\\\" EXAMPLE state = State(1, set(23, 0)) # Diamond 12, Club\",\n \"an array of length-52: We call this Map \\\"weights\\\". And the array of\",\n \"\\\".csv\\\", 'a') as k: k.write( f\\\"{game + 1},\\\" f\\\"{NS_Wins[-1]},{NS_Wins_random[-1]},{NS_Wins[-1] - NS_Wins_random[-1]},\\\" f\\\"{rfv[0]},{rftc[0]},\\\" f\\\"{rfv[1]},{rftc[1]},\\\"\",\n \"Diamond 2 -> Diamond 14 Cards 26 -> 38 are Heart 2 ->\",\n \"'''''''''''''''''''''''''''''''''''''''''''''''''''''''''\\\"\\\"\\\" class BridgeAgentRedFlags: def __init__(self): self.RED_FLAG_VIOLATIONS = np.zeros(3) self.RED_FLAG_TOTAL_COUNT = np.zeros(3) self.ALL_RED_FLAG_VIOLATIONS =\",\n \"each hand. Note: Ace is 12, 25, 38, 51 \\\"\\\"\\\" def count_points(hands): points\",\n \"\\\", end=\\\"\\\", flush=True) rfv = barf.RED_FLAG_VIOLATIONS rfv_random = barf_random.RED_FLAG_VIOLATIONS rftc = barf.RED_FLAG_TOTAL_COUNT rftc_random\",\n \"# valid_cards = [20, 24] valid_cards = np.array([i for i in range(suit *\",\n \"to play (only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER\",\n \"13 and card > max_val: max_val, max_idx = card, idx return max_idx \\\"\\\"\\\"\",\n \"card_3]), card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 #\",\n \"list(range(suit * 13, (suit + 1) * 13)) valid_cards = np.array([i for i\",\n \"if it has Diamonds. In this example, agent will most likely play 24,\",\n \"card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card. round_winner = (determine_round_winner(opening_suit,\",\n \"is -1 <-- used in a \\\"State\\\" where no cards have been played\",\n \"% 4 # Adjust the BridgeAgent weights. # If the BridgeAgent or N\",\n \"self.RED_FLAG_TOTAL_COUNT = np.zeros(3) \\\"\\\"\\\" This function checks if the agent plays their highest\",\n \"\\\"\\\"\\\" def highest_card(self, valid_cards, agent_valid_cards, card): if len(agent_valid_cards) > 1 and max(valid_cards) >\",\n \"they play their partner's cards if ba and declarer: agent_state_2 = State(opening_suit, frozenset(cards_played),\",\n \"Agent's cards hands[3] = West's cards \\\"\\\"\\\" round_winner = (d + 1) %\",\n \"\\\"\\\"\\\" This function counts the points in each hand. Note: Ace is 12,\",\n \"= State(1, set(23, 0)) cards_in_hand = set(0, 1, 4, 8, 11, 20, 24,\",\n \"(only some are valid). NUM_GAMES_TRAIN = 10000 NUM_GAMES_TEST = 10000 STATS_PER = 1000\",\n \"partners_cards): all_valid_cards = list(range(suit * 13, (suit + 1) * 13)) valid_cards =\",\n \"14 Cards 13 -> 25 are Diamond 2 -> Diamond 14 Cards 26\",\n \"hand: if card % 13 == 12: p += 4 elif card %\",\n \"partnership has more points and agent is declarer if points[0] + points[2] >\",\n \"+ 1) % 4 # the person to the right of the declarer\",\n \"# if agent is declarer, they play their partner's cards if ba and\",\n \"State(opening_suit, frozenset(cards_played), agent_card_played[0]) states_accessed.append(agent_state_2) card = ba.play_card(agent_state_2, hands[player_idx]) barf.assess_card_played(hands, card, opening_suit, cards_played, player_idx,\",\n \"card_partner) self.weights[state] = np.full(NUM_ACTIONS, 1.0) # self.alpha = 0.997 # 1,000 # self.alpha\"\n]","isConversational":false}}},{"rowIdx":3999,"cells":{"ngram":{"kind":"list like","value":["hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async","hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await","test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir","= [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write()","= HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir await data.restore()","tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs()","hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data","data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass =","import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import","import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository","[repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio","data = HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version","import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import","data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration","= HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version =","= HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def","Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir):","from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from","= HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration =","repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \"1\" hacs.repositories = [repository] hacs.hass","hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await","from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs =","= Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def","import pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from","= HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled =","HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False","import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import","= False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs =","async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir","@pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant()","get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False","import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def","@pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository = dummy_repository_base()","HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \"1\"","tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio","custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async","dummy_repository_base() repository.data.installed = True repository.data.installed_version = \"1\" hacs.repositories = [repository] hacs.hass = HomeAssistant()","from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from","= tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data =","def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir =","os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository","hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data","aiogithubapi.objects import repository import pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data","custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data =","\"1\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration()","tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData()","= tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write()","repository import pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData","repository.data.installed_version = \"1\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration","await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass","False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData()","hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \"1\" hacs.repositories","pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository","hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs","test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True","False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs()","await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass","from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio","= get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \"1\" hacs.repositories =","from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data","Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs()","repository.data.installed = True repository.data.installed_version = \"1\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir","HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration()","import repository import pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import","= True repository.data.installed_version = \"1\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir =","dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository =","True repository.data.installed_version = \"1\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir","def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir =","hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs","HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir):","HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base","= dummy_repository_base() repository.data.installed = True repository.data.installed_version = \"1\" hacs.repositories = [repository] hacs.hass =","= False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data =","hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task","data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir await","hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled","hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async","Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir):","= Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs =","HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs","import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData()","data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass =","custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository","Suite.\"\"\" from aiogithubapi.objects import repository import pytest import os from homeassistant.core import HomeAssistant","homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration","test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir","\"\"\"Data Test Suite.\"\"\" from aiogithubapi.objects import repository import pytest import os from homeassistant.core","async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed","async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir","@pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant()","custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share","= get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task =","from aiogithubapi.objects import repository import pytest import os from homeassistant.core import HomeAssistant from","Test Suite.\"\"\" from aiogithubapi.objects import repository import pytest import os from homeassistant.core import","import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import","def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed =","get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs","= \"1\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration =","from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from","HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration","get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \"1\" hacs.repositories = [repository]"],"string":"[\n \"hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async\",\n \"hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await\",\n \"test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir\",\n \"= [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write()\",\n \"= HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir await data.restore()\",\n \"tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs()\",\n \"hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data\",\n \"data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass =\",\n \"import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import\",\n \"import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository\",\n \"[repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio\",\n \"data = HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version\",\n \"import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import\",\n \"data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration\",\n \"= HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version =\",\n \"= HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def\",\n \"Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir):\",\n \"from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from\",\n \"= HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration =\",\n \"repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \\\"1\\\" hacs.repositories = [repository] hacs.hass\",\n \"hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await\",\n \"from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs =\",\n \"= Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def\",\n \"import pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from\",\n \"= HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled =\",\n \"HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False\",\n \"import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import\",\n \"= False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs =\",\n \"async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir\",\n \"@pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant()\",\n \"get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False\",\n \"import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def\",\n \"@pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository = dummy_repository_base()\",\n \"HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \\\"1\\\"\",\n \"tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio\",\n \"custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async\",\n \"dummy_repository_base() repository.data.installed = True repository.data.installed_version = \\\"1\\\" hacs.repositories = [repository] hacs.hass = HomeAssistant()\",\n \"from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from\",\n \"= tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data =\",\n \"def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir =\",\n \"os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository\",\n \"hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data\",\n \"aiogithubapi.objects import repository import pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data\",\n \"custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data =\",\n \"\\\"1\\\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration()\",\n \"tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData()\",\n \"= tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write()\",\n \"repository import pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData\",\n \"repository.data.installed_version = \\\"1\\\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration\",\n \"await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass\",\n \"False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData()\",\n \"hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \\\"1\\\" hacs.repositories\",\n \"pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository\",\n \"hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs\",\n \"test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed = True\",\n \"False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs()\",\n \"await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass\",\n \"from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio\",\n \"= get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \\\"1\\\" hacs.repositories =\",\n \"from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data\",\n \"Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs()\",\n \"repository.data.installed = True repository.data.installed_version = \\\"1\\\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir\",\n \"HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration()\",\n \"import repository import pytest import os from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import\",\n \"= True repository.data.installed_version = \\\"1\\\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir =\",\n \"dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository =\",\n \"True repository.data.installed_version = \\\"1\\\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir\",\n \"def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir =\",\n \"hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs\",\n \"HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir):\",\n \"HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base\",\n \"= dummy_repository_base() repository.data.installed = True repository.data.installed_version = \\\"1\\\" hacs.repositories = [repository] hacs.hass =\",\n \"= False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data =\",\n \"hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task\",\n \"data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir await\",\n \"hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled\",\n \"hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await data.async_write() @pytest.mark.asyncio async\",\n \"Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir):\",\n \"= Configuration() await data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs =\",\n \"HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs\",\n \"import get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData()\",\n \"data.async_write() @pytest.mark.asyncio async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass =\",\n \"custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import get_hacs from tests.dummy_repository\",\n \"Suite.\\\"\\\"\\\" from aiogithubapi.objects import repository import pytest import os from homeassistant.core import HomeAssistant\",\n \"homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration\",\n \"test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir\",\n \"\\\"\\\"\\\"Data Test Suite.\\\"\\\"\\\" from aiogithubapi.objects import repository import pytest import os from homeassistant.core\",\n \"async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed\",\n \"async def test_hacs_data_async_write2(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir\",\n \"@pytest.mark.asyncio async def test_hacs_data_restore(tmpdir): data = HacsData() hacs = get_hacs() hacs.hass = HomeAssistant()\",\n \"custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share\",\n \"= get_hacs() hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task =\",\n \"from aiogithubapi.objects import repository import pytest import os from homeassistant.core import HomeAssistant from\",\n \"Test Suite.\\\"\\\"\\\" from aiogithubapi.objects import repository import pytest import os from homeassistant.core import\",\n \"import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration from custom_components.hacs.share import\",\n \"def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs = get_hacs() repository = dummy_repository_base() repository.data.installed =\",\n \"get_hacs from tests.dummy_repository import dummy_repository_base @pytest.mark.asyncio async def test_hacs_data_async_write1(tmpdir): data = HacsData() hacs\",\n \"= \\\"1\\\" hacs.repositories = [repository] hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration =\",\n \"from homeassistant.core import HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from\",\n \"HomeAssistant from custom_components.hacs.hacsbase.data import HacsData from custom_components.hacs.helpers.classes.repository import HacsRepository from custom_components.hacs.hacsbase.configuration import Configuration\",\n \"get_hacs() repository = dummy_repository_base() repository.data.installed = True repository.data.installed_version = \\\"1\\\" hacs.repositories = [repository]\"\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":39,"numItemsPerPage":100,"numTotalItems":12866649,"offset":3900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MzU1Nzk5MywianRpIjoiZmIwZGZmYTAtYWYzMi00OWE0LTgzNWUtNDg1Y2IwMGZjYzQ3Iiwic3ViIjoiL2RhdGFzZXRzL3RlcnJ5eXovc3RhcmNvZGVyZGF0YV9uZ3JhbV8xMyIsImV4cCI6MTc4MzU2MTU5MywiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.tgfmwTsLb03wut59JFK6SE9c9I8svImMsuifkM9J0ttBiApdlXHU_DFb1Ke98op5JEdkZT3vohaJebbeTBO5Aw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":12866649,"numBytesParquet":149232926747}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
ngram listlengths 0 67.8k |
|---|
[
"import commands from discord.utils import get class c8(commands.Cog, name=\"c8\"): def __init__(self, bot: commands.Bot):",
"@commands.command(name='Sacrosanct_Devouring_Pyre', aliases=['c8']) async def example_embed(self, ctx): embed = discord.Embed(title='Sacrosanct Devouring Pyre', color=0xBC5A84) embed.set_t... |
[
"from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.model_selection import StratifiedKFold # Open preproccessed csv df",
"print(\"Min Accuracy:\", np.min(accuracies)) print(\"Mean of Accuracies:\", np.mean(accuracies)) print(\"STD of Accuracies:\", np.std(accuracies)) # print(\"RUNNING",
"... |
[
"from rsterm import EntryPoint from red_dwarf.project import provide_project_context, ProjectContext class InitProject(EntryPoint): @provide_project_context def",
"import provide_project_context, ProjectContext class InitProject(EntryPoint): @provide_project_context def run(self, project_context: ProjectContext) ... |
[
"split_line[5] bases = \"\" # Replace the '.' and ',' signs with the",
"'\\n'); # sys.stderr.write('line:\\n'); # sys.stderr.write(line.strip() + '\\n'); # most_common_base_count = 0; # Allow",
"= %s\\tbase_counts = %s\\tinsertion_counts = %s\\tdeletion_counts = %s\\t%s\" % ( position, ref_name, int(coverage),"... |
[
"OpenERP, Open Source Management Solution # Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>). #",
"# GNU Affero General Public License for more details. # # You should",
"from openerp.osv import fields, osv class account_payment_populate_statement(osv.osv_memory): _name = \"account.payment.populate.statemen... |
[
"course. Widget requirements: keyring_. .. _keyring: https://pypi.org/project/keyring/ \"\"\" defaults = [ ('mbox', '\"INBOX\"',",
"(changing out <userid> and <password> for your userid and password): 1) create the",
"TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT."... |
[
"get_game_def_response.status_code == 200 assert get_game_def_response.data == post_game_def_response.data def test_game_def_not_found_by_int_id(api_client): post_game_def_response = create_game_definition(api_client) assert",
"post_game_def_response.data def test_game_def_not_found_by_int_id(api_client): post_ga... |
[
"a Program That Reads a list of strings. Each string is repeated N",
"repeated N times, where N is the length of the string. Print the",
"Write a Program That Reads a list of strings. Each string is repeated",
"output_string = \"\" for string in strings: N = len(string) output_string += string",
"N times, w... |
[
"get_arg_parser, ArgumentParser from cloudkeeper_plugin_cleanup_aws_loadbalancers import CleanupAWSLoadbalancersPlugin def test_args(): arg_parser = get_arg_parser() CleanupAWSLoadbalancersPlugin.add_args(arg_parser) arg_parser.parse_args()",
"import CleanupAWSLoadbalancersPlugin def test_args(): arg_parser = get... |
[
"dependencies = [ ('metadata', '0010_auto_20180823_2353'), ] operations = [ migrations.AlterField( model_name='documentmetadata', name='value', field=models.CharField(blank=True,",
"name='name', field=models.CharField(help_text='Name used by other apps to reference this metadata type. Do not",
"-*- # Generated ... |
[
"now = queue.pop(0) print(now, end=' ') for n in graph[now]: if not visited[n]:",
"visited[n]: dfs(n) def dfs_s(V): stack = [V] visited[V] = True while stack: now",
"graph = [[] for _ in range(N + 1)] for i in range(M):",
"n in graph[now]: if not visited[n]: stack.append(n) visited[n] = True def bfs(V): visit... |
[
"__author__ = \"<NAME>, <NAME>, and <NAME>\" __copyright__ = \"Copyright 2013-2015 UKP TU Darmstadt\"",
"import webapp from google.appengine.ext.webapp.util import run_wsgi_app __author__ = \"<NAME>, <NAME>, and <NAME>\" __copyright__",
"self.redirect(\"/argunit/home\") def post(self): self.redirect(\"/argunit/... |
[
"final. Use instead :: from imgaug import augmenters as iaa and then e.g.",
"Augmenter class Fliplr(Augmenter): # pylint: disable=locally-disabled, unused-variable, line-too-long \"\"\" Flip/mirror input images horizontally.",
"keypoints_on_image.shape[1] for keypoint in keypoints_on_image.keypoints: keypoint.x... |
[
"l2.val tempsum += carry if tempsum > 9: carry = tempsum//10 tempsum %=",
"tempsum//10 tempsum %= 10 else: carry = 0 temp.next = ListNode(tempsum) temp =",
"= temp = ListNode() while l1 is not None and l2 is not",
"not None and l2 is not None: tempsum = l1.val + l2.val tempsum",
"= ListNode(tempsum) temp = ... |
[
"init hidden layers to be near deterministic for layer in dgp.layers[:-1]: layer.q_sqrt.assign(layer.q_sqrt *",
"import Gaussian from deep_gp import DeepGP np.random.seed(0) tf.random.set_seed(0) def get_data(): Ns = 300",
"Xs, X, Y, Z def make_deep_GP(num_layers, X, Y, Z): kernels = [] layer_sizes",
"range(1... |
[
"= executor self.storage = executor.storage self.bucket, raw_prefix = sm_storage['centroids'] self.prefix = f\"{raw_prefix}/{self.ds_hash}\" self.config_key",
"None moldb_cache.clear() if cached_val: db_data_cobjs, peaks_cobjs = cached_val logger.info( f'Loaded {len(db_data_cobjs)} DBs, {len(peaks_cobjs)}",
"va... |
[
"= list() # for each connection get the node connected to the bottom",
"to provide top connector functionality \"\"\" def __init__(self, index, nodeItem, nodeEditor, parent=None): super(ConnectorTopItem,",
"is a top connector (implementation for parent class) \"\"\" return True def isInPlace(self):",
"parent)... |
[
"Commons Clause Restriction # # The Software is provided to you by the",
"keys are present in cache. :param connection: connection to Ignite server, :param cache:",
"defined below, subject to # the following condition. # # Without limiting other",
"Union from pyignite.queries.op_codes import * from pyignite.d... |
[
"path + \"/report\" report_file = report_path + \"/wrt-manifest-tizen-tests.xml\" report_summary_file = report_path + \"/summary.xml\"",
"path + \"/result\" path_allpairs = path + \"/allpairs\" path_resource = path + \"/resource\"",
"sh_path = path + \"/script\" log_path = report_path + \"/log_\" device_path = ... |
[
"move the pipettes and gantry over the trash # do not home plunger",
"thermocycler_hardware is not None: await thermocycler_hardware.open() return OpenLidResult() class OpenLid(BaseCommand[OpenLidParams, OpenLidResult]): \"\"\"A command",
"from __future__ import annotations from typing import Optional, TYPE_CHE... |
[
":param text: :param chars_to_mapping: :return: \"\"\" import re pattern = \"|\".join(map(re.escape, chars_to_mapping.keys())) return",
"function is used to replace a dictionary of characters inside a text string",
"multiple_replace(text: str, chars_to_mapping: dict): \"\"\" This function is used to replace a d... |
[
"models.CharField(max_length=500) repo_name = models.CharField(max_length=512, blank=True, null=True) user_name = models.CharField(max_length=512, blank=True, null=True) def __str__(self):",
"here. class Gamedoc(models.Model): link = models.URLField(max_length=500) title = models.CharField(max_length=500) repo_na... |
[
"django.contrib import admin from users.models import Friendship admin.site.register(Friendship) # Register your models here.",
"from django.contrib import admin from users.models import Friendship admin.site.register(Friendship) # Register your models"
] |
[
"number: %s' % len(doc.paragraphs)) print('1st paragraph: %s' % doc.paragraphs[0].text) print('2nd paragraph: %s' %",
"% len(doc.paragraphs)) print('1st paragraph: %s' % doc.paragraphs[0].text) print('2nd paragraph: %s' % doc.paragraphs[1].text) print('paragraphs",
"%s' % doc.paragraphs[0].text) print('2nd para... |
[
"from BD.util.paths import Paths def sims_analysis_BD(): input_folder = Paths.rest_path + 'archive/beh/qlp-ml-opt/qlp-ml/' sims_analysis(input_folder, Paths.local_path",
"= Paths.rest_path + 'archive/beh/qlp-ml-opt/qlp-ml/' sims_analysis(input_folder, Paths.local_path + 'BD/to_graph_data/qlp_ml_onpolicy__stats.cs... |
[
"** 32 - 1)) | ((v << 24) & (2 ** 32 -",
"re.search(r'#define SW2_SEED (0x[a-fA-F0-9]{8})', code) assert match is not None, 'SW2_SEED not found!' return",
"= code.split('#elif defined(__GNUC__)')[3] for syscall_name in syscall_names: regex = re.compile('NTSTATUS ' + syscall_name",
"function_name, old_hash in ... |
[
"code ({}): {}\".format(abs(response.returncode), errmsg) return response.returncode, stderr def execute(cmd, workdir=None, timeout=60): cmd =",
"dict): errmsg = errmsg[\"descr\"] else: errmsg = response.stderr stderr = \"Exit code ({}):",
"errmsg[\"descr\"] else: errmsg = response.stderr stderr = \"Exit code (... |
[
"targets: target = targets[self.name] self.update(target) else: logger.warn(\"Port forward setting named \" + self.name",
"update(self, target): if self.forward_type is not None: target[\"type\"] = self.forward_type if self.remote_host is",
"not None: target[\"local_port\"] = self.local_port if self.ssh_server ... |
[
"KIND, either express or implied. # See the License for the specific language",
"Unless required by applicable law or agreed to in writing, software # distributed",
"StringIO import traceback import unittest from xTool import atfork class AtforkTest(unittest.TestCase): def setUp(self):",
"parent error\" in er... |
[
"path.rglob(). :param Path path: path to list recursively :return list: list of Path",
"bool file: Boolean, does the given path end with a file? If not,",
"= [] for file in path.rglob('*'): files.append(file) return files def scan_and_create_dir_tree(path, file=True): \"\"\"",
"the supplied path \"\"\" levelt... |
[
"class indices node.out_port(2).set_data_type(in_data_type) if node.is_out_port_connected(3): node.out_port(3).set_data_type(np.int32) # the fourth output contains batch indices",
"def backend_attrs(self): return [ ('class_agnostic_box_regression', lambda node: str(bool(node['class_agnostic_box_regression'])).low... |
[
"f.lower().startswith('.') and f.lower().endswith('psv'): files.append(f) if not os.path.isdir(output_directory): os.mkdir(output_directory) # Load model. model =",
"data def save_challenge_predictions(file, scores, labels): with open(file, 'w') as f: f.write('PredictedProbability|PredictedLabel\\n') for (s,",
... |
[
"\"w\") f.write(cls.outputString) f.close() @classmethod def report(cls): \"\"\" \"\"\" # Duration durationStatement = cls.duration()",
"cls.plotData() @classmethod def plotData(cls): \"\"\" \"\"\" print('-----------------------------------------') print(cls.popsData) data = list(cls.popsData.values())[0] # Plots... |
[] |
[
"else: raise ValueError(\"Your sample sheet must have a Sample_ID column, or (Sentrix_ID and",
"['x_median', 'y_median', 'predicted_sex', 'X_fail_percent', 'Y_fail_percent'] - color is sex, pink or blue -",
"<reponame>FoxoTech/methylcheck<filename>methylcheck/predict/sex.py import pandas as pd import numpy as n... |
[
"'0002_auto_20201115_1531'), ] operations = [ migrations.AlterField( model_name='customuser', name='user_id', field=models.IntegerField(blank=True, null=True, unique=True, validators=[django.core.validators.MaxValueValidator(99999), django.core.validators.MinValueValidator(10000),",
"= [ migrations.AlterField( mo... |
[
"tip1plainbody = fix_line_endings( \"Modify your last commit before pushing with `git commit --amend`.\\n\"",
"it doesn't crashfail\"\"\" subprocess.check_call([\"git-fortune\"]) captured = capfd.readouterr() assert \"GIT TIP #\" in captured.out",
"TIP #\" in captured.out # from the box format def test_category... |
[
"# conv_out_channels=512, # num_keypoints=5, # loss_keypoint=dict(type='MSELoss', loss_weight=50.0)), keypoint_decoder=dict(type='HeatmapDecodeOneKeypoint', upscale=4), bbox_roi_extractor=dict( type='SingleRoIExtractor', roi_layer=dict(type='RoIAlign', output_size=7,",
"1.0]), loss_cls=dict( type='CrossEntropyLos... |
[
"All Rights Reserved. import torch, math from torch import nn from torch.autograd import",
"bs, ch, h, w, zsize, sampling_ratio, ) return grad_input, None, None, None, None",
"output = _C.roi_align_rotated_3d_forward( input, roi, spatial_scale, output_size[0], output_size[1], output_size[2], sampling_ratio ) # ... |
[
"sequenceLength = _padSequences(sequences, padtok, maxLength) elif nlevels == 2: maxLengthWord = max([max(map(lambda x:",
"tagType = tagName.split('-')[-1] return tagClass, tagType def getChunks(seq, tags): \"\"\"Given a sequence of",
"f: line = line.strip().split(' ') word = line[0] if word in dictionary: embe... |
[] |
[
"# pylint: disable=W0640 df = df.fillna(\"\") df.set_index(\" \", inplace=True) # Debug user output",
"= df[col].map(lambda x: value.format(x)) # pylint: disable=W0640 df = df.fillna(\"\") df.set_index(\" \", inplace=True)",
"[WSJ] Currencies\" embed = disnake.Embed(title=title, colour=cfg.COLOR) embed.set_imag... |
[
"queries allows searching up the chain # for attributes. If not found in",
"recipe_name[-4:] == '.yml': recipe_name = recipe_name[:-4] elif recipe_name[-5:] == '.yaml': recipe_name = recipe_name[:-5]",
"if len(RECIPES) == 1 and name != 'default': RECIPES['default'] = RECIPES[data['name']] for recipe",
"yaml.l... |
[
"from .torch2onnx import torch2onnx from .onnx2trt import onnx2trt from .torch2trt import torch2trt from",
".torch2onnx import torch2onnx from .onnx2trt import onnx2trt from .torch2trt import torch2trt from .base",
"from .onnx2trt import onnx2trt from .torch2trt import torch2trt from .base import load, save",
... |
[
"7, 'Note that this error indicates losing other scores!' vid_names, all_scores = [],",
"s).sum(-1) score = intersection / union return score def forward_loss(self, batch_data, step=None): enc_outs",
"rel_edges) return { 'sent_embeds': sent_embeds, 'sent_lens': sent_lens, 'verb_embeds': verb_embeds, 'verb_lens'... |
[
"authentication.interfaces.token import verify_token router = APIRouter() security = HTTPBasic(auto_error=True) api_key = APIKeyHeader(name=\"x-api-key\", auto_error=True)",
"\"secret\": authorization.password}, ) if not profiles: raise HTTPException(status_code=HTTP_401_UNAUTHORIZED) user[\"acl\"] = jsonable_enc... |
[
"print (next_waypoint) q.put((takeoff_drone, { \"drone_id\" : drone_id, \"waypoints\" : waypoints[next_waypoint:] })) def create_new_drone(kwargs):",
"value): node.update_drone(drone_id, { \"heading\": value }) mq.put((attach_listener, { \"attach_fn\" : drone.add_attribute_listener, \"attr\" :",
"waypoints.inde... |
[
"# 将字符串按照其长度进行分组 dp = {} for word in words: pool[len(word)].append(word) for key in",
"dp[j] + 1) (0 <= j < i 且 words[j] 是 words[i] 的前身)",
"if length < 2: # return length # dp = [1 for _",
"20:35:25 # @Runtime: 144 ms # @Memory: 13.3 MB class Solution: # #",
"True # # return False # # word2 去除任意一个位置的字符后与 wo... |
[
"import partial def duplicateChain(*args): global ogChain global chainLen global switcherLoc global side global",
"True) cmds.rename(shapeList, ikFootControl + \"Shape\") ikFootControlGrp = cmds.group(em=1, n=ikFootControl + \"_grp\") cmds.parent(ikFootControl, ikFootControlGrp)",
"channels and then connect the... |
[
"= 0 while not results.empty(): # Safe because all jobs have finished result",
"size))) newImage = oldImage.subsample(stride) newImage.save(targetImage) return Result(0, 1, targetImage) def summarize(summary, concurrency): message",
"not os.path.exists(args.target): os.makedirs(target) return args.size, args.sm... |
[
"set `delete` to False and run # test once. Then also set `index`",
"this method also asserts that we can instantiate a local ES client pointing",
"= self._check_endpoint(endpoint=config.service_endpoint(), path=f'/fetch/repository/files/{file_uuid}', query=dict(catalog=catalog)) response = json.loads(response)... |
[
":type user: str :param data_transformation: An old DataTransformationto be updated :type data_transformation: dict",
"noqa: E501 \"\"\"List all instances of DataTransformation Gets a list of all instances",
"https://w3id.org/okn/o/sd#DataTransformation) # noqa: E501 :param user: Username :type user: str :param... |
[
"matplotlib.pyplot as pl import matplotlib except ImportError: warnings.warn(\"matplotlib could not be loaded!\") pass",
"pass from . import labels from . import colors def truncate_text(text, max_len): if",
"None: feature_names = features.columns features = features.values pl.figure(figsize=(10,3)) ys = shap_v... |
[
"wszystko co możliwe, nie ma pliku, zly master itp. i zwrocic 1 wyjątek",
"file + \".yaml\").get_all() for srv in servers: if view == 'tree': print(\"| +-\",",
"dla keepasa def do_setMaster(self,args): \"Set master password\" if sys.stdin.isatty(): # jezeli jako shell",
"wykonywać print(\"Exec on:\") for file... |
[
"parallelisation (where possible), sets the internal variables for evaluating the exact solution and",
"fempde2.exec_time 3.830256175994873 >>> fempde2.mem_consumption 76705792 \"\"\" def __init__(self, show_gui, max_ndof=50000): super().__init__(show_gui) # init",
"Attributes ---------- max_nodf: int the maxim... |
[
"plotting import matplotlib.pyplot as plt for i in range(12): #plot edges for j",
"2.3405 1.0868 1.5293 2.2197 1.0148 1.2083 1.3041 \"\"\")# network power demands # graph",
"2; 4; 7\") # maximum generator power c = np.matrix(\"4; 8; 5; 3\")",
"0 1 0 0 1 ; 0 0 0 0 0 0 0",
"0 0 0 0 0 0 0 0 0 0 0 1 0",
"text... |
[
"between values of any two nodes. # # Example: # # Input: #",
"which is the difference between 2 and 1 (or between 2 and 3).",
"# Input: # # 1 # \\ # 3 # / # 2",
"# # 1 # \\ # 3 # / # 2 # #",
"# Output: # 1 # # Explanation: # The minimum absolute difference is",
"and 1 (or between 2 and 3). # Definition f... |
[
"= '%Y-%m-%dT%H:%M:%S.%f%z' def in_error(self, message): self.message = message def backend_error(self, msg): raise BackendError(msg)",
"BackendError import datetime, logging logger = logging.getLogger(__name__) CHOICES_APE = dict(choices.APE) CHOICES_LEGALFORM = dict(choices.LEGALFORM)",
"date): return datetim... |
[
"engine = create_engine(SQLALCHEMY_DATABASE_URL) SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) Base = declarative_base() def get_db():",
"Base = declarative_base() def get_db(): db = SessionLocal() try: yield db finally: db.close()",
"= create_engine(SQLALCHEMY_DATABASE_URL) Sessio... |
[
"get_all(self): for (name, _) in self.storage_classes.iteritems(): yield name class RPlacementTarget: def __init__(self, name,",
"try: cur[name][var] = cfg.getint(section, var) except ConfigParser.NoOptionError: pass for var in bool_config_opts: try:",
"import yaml import ConfigParser import rados from boto.s3.... |
[] |
[] |
[
"0], \"B\": [10, 30], \"C\": [0, 10], \"D\": [0, 0]} result = is_intersect(**args)",
"{\"prev_center\": [0, 0], \"current_center\": [10, 0]}, # Right {\"prev_center\": [10, 0], \"current_center\": [0,",
"[0, 10], \"current_center\": [0, 0], \"expect\": True}, \"bottom\": {\"prev_center\": [0, 0], \"current_cent... |
[] |
[
"= ps.create_runs_upto(3) self.assertEqual([r.id for r in runs], [0, 1, 2]) self.assertEqual([r.seed for r",
"self.assertEqual([r.seed for r in runs], [0, 1, 2]) def test_is_finished(self): ps = ParameterSet.find_or_create(0,",
"caravan.tables import Tables from caravan.parameter_set import ParameterSet class P... |
[
"indirect=True) @pytest.mark.parametrize(\"test_s3_enabled\", [True], indirect=True) def test_correct_enabled( self, test_s3_enabled: bool, test_s3_autocreate_buckets: bool, test_s3_manager_settings: OverhaveS3ManagerSettings,",
"bool) -> None: settings = OverhaveS3ManagerSettings(enabled=test_s3_enabled) assert ... |
[
"of the remainder of the line. 4. Typing an empty line repeats the",
"list. \"\"\" return [] def completenames(self, text, *ignored): dotext = 'do_'+text return [a[3:]",
"AttributeError: try: doc=getattr(self, 'do_' + arg).__doc__ if doc: self.stdout.write(\"%s\\n\"%str(doc)) return except AttributeError: pass"... |
[
"has_add_permission(self, request): return False @admin.register(receiverInfo) class receiverInfoAdmin(admin.ModelAdmin): date_hierarchy = 'created_at' list_display = ('id',",
"= 25 search_fields = ('user__phone_number', 'user__email', 'code') readonly_fields = ('user','cart', 'receiver', 'payment_mode', 'shippin... |
[
"Node(val, self.head) self._size += 1 def append(self, val): \"\"\" appends node to the",
"in reversed(iter): self.insert(item) def __repr__(self): \"\"\" assumes head will have a val and",
"if current._next.val == val: new_node._next = current._next current._next = new_node self._size += 1",
"= None self._si... |
[
"= cms.untracked.uint32(1) ) process.load(\"Configuration.StandardSequences.MagneticField_cff\") process.load(\"Geometry.CMSCommonData.cmsIdealGeometryXML_cfi\") process.load(\"Geometry.CommonTopologies.globalTrackingGeometry_cfi\") process.load(\"RecoMuon.DetLayers.muonDetLayerGeometry_cfi\") process.load(\"Geomet... |
[
"predicted_B.extend(torch.argmax(outputs[1], axis=1).cpu().numpy().tolist()) del model return original_A, original_B, predicted_A, predicted_B def train_and_save(self, texts, labels,",
"np.array(labels) skf = StratifiedKFold(n_splits=splits) original = [] predicted = [] for train_index, test_index",
"attention_... |
[
"data=None): self.action = action self.data = data class Rsponse: def __init__(self): self.status =",
"Message class Implementation # @author: <NAME> <<EMAIL>> class Message: class Request: def __init__(self,",
"class Message: class Request: def __init__(self, action=\"\", data=None): self.action = action self.... |
[
"#!/usr/bin/python from mod_pywebsocket import msgutil import time def web_socket_do_extra_handshake(request): pass # Always accept.",
"msgutil import time def web_socket_do_extra_handshake(request): pass # Always accept. def web_socket_transfer_data(request): time.sleep(3) msgutil.send_message(request,",
"mod_... |
[
"an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND,",
"distributed on an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY",
"super().__init__(**kwargs) if not (command or powershell): raise ValueError(\"Must provide either 'command' or 'powershell'\")",
"express or implied. See th... |
[
"convert_group_settings(group_name, setting): \"\"\"Convert UserGroupSettings to UserGroupSettingsWrapper.\"\"\" return api_pb2_v1.UserGroupSettingsWrapper( groupName=group_name, who_can_view_members=setting.who_can_view_members, ext_group_type=setting.ext_group_type, last_sync_time=setting.last_sync_time) def",
... |
[
"= relation self.query_executer = kg_query_interface self.quality = quality self.quality_aggregation = quality_aggregation self.labels_indexer=Indexer(store=kg_query_interface.type, endpoint=kg_query_interface.endpoint,",
"'') else: out_str = str(p) out_file.write(out_str) out_file.write('\\n') with open(out_file... |
[
"return any(filename.endswith(extension) for extension in IMG_EXTENSIONS) def dataloader(filepath): left_fold = 'image_2/' train =",
"'.jpeg', '.JPEG', '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP', ] def is_image_file(filename): return any(filename.endswith(extension)",
"IMG_EXTENSIONS = [ '.jpg', '.JPG', '.j... |
[] |
[
"def get_quote_list(request): \"\"\" Get list of quotes IDs. \"\"\" page = int(request.params.get(\"page\", \"0\"))",
"from weaver.processes.types import PROCESS_APPLICATION, PROCESS_WORKFLOW from weaver.processes.wps_package import get_package_workflow_steps, get_process_location from weaver.store.base import",
... |
[
"col1, col2, col3, strava_button @st.cache(show_spinner=False) def get_activities(auth, page=1): access_token = auth[\"access_token\"] response =",
"STRAVA_CLIENT_ID, \"redirect_uri\": APP_URL, \"response_type\": \"code\", \"approval_prompt\": \"auto\", \"scope\": \"activity:read_all\" } ) return request.url",
... |
[
"import gettext progName = ufw.common.programName gettext.install(progName)#, unicode=True) # for i18n; fixes '_' not",
"else: run('allow ' + pp) def deny(port=None, protocol=None): # port int; protocol str",
"ufw.reset() # restore defaults # ufw.status() # return status string (default verbose=True) #",
"pr ... |
[
"test_funcs() libsalt.simulationStep() step = libsalt.getCurrentStep() libsalt.close() print(\"Python: Simulation End!!!\") def test_funcs(): standbys =",
"<reponame>etri-city-traffic-brain/traffic-simulator import libsalt def test(salt_scenario): libsalt.start(salt_scenario) libsalt.setCurrentStep(25200) step = ... |
[
"-15, -10), \"Copy\", sizeStyle='small', callback=self.buttonCallback) self.w.setDefaultButton( self.w.copybutton ) # Load Settings: if not",
"c<0): scale_y = scale_y * -1 rotation = math.atan2(b, a) * (180/math.pi) return",
"layer\" for i in range( num_into )[::-1]: del targetLayer.paths[i] if num_from > 0:",
... |
[
"in enumerate(codes): filename = \"filename%i\" % idx contents[filename] = code start = code.index(\"S\")",
"S____ E \"\"\"), \"\"\"\\ at filename0 line 1: S____ ~~~~~\"\"\") def test_describes_multi_file_location(self): self.assertEqual(",
"If a copy of the MPL was not distributed with this file, #",
"1: S ~... |
[
"bind = config[\"BIND\"], cont = config[\"CONT\"] benchmark: \"benchmarks/star_SP/{samples}.tsv\" message : \"Running STAR second",
"= ancient(config[\"REF\"] + \"REindexing_done.txt\"), R1 = config[\"TRIMMED\"] + \"{samples}_trim.fastq.gz\", genomeDir = ancient(config[\"REF\"]) output:",
"# # Inputs: # - sampl... |
[
"= models.EmailField() job_title = models.CharField(max_length=60) job_description = models.TextField() salary = models.PositiveIntegerField() city =",
"company_name = models.CharField(max_length=50) company_email = models.EmailField() job_title = models.CharField(max_length=60) job_description = models.TextField... |
[
"comment=comment, created_on=datetime.now()) comment_content.save() profile.comments_number = profile.comments_number + 1 profile.save() return redirect('index') else: print('form",
"login(request,user) return redirect('index') else: messages.error(request, 'Error occured during registration') context = {'reg_for... |
[
"in xml_lexicon: lemgrams = [] for saldo, match in list(xml_lexicon[lem].items()): lemgrams.append(PART_DELIM1.join([saldo, match])) picklex[lem]",
"log.info(\"OK, read %d words\", len(self.lexicon)) def lookup(self, lem): \"\"\"Lookup a word in the",
"out_annotation.append(util.AFFIX + util.DELIM.join(set(sald... |
[
"= os.path.abspath(os.path.join(os.path.dirname(__file__), \"../config\")) return config_path def get_data_path(): data_path = os.path.abspath( os.path.join(os.path.dirname(__file__), \"../../../data/\") )",
"import os def get_root_path(): current_path = os.path.abspath(os.path.dirname(__file__)) root_path = os.p... |
[
"import hooks @hooks.register('insert_editor_js') def enable_source(): return format_html( \"\"\" <script> registerHalloPlugin('hallohtml'); </script> \"\"\" )",
"django.utils.html import format_html from wagtail.wagtailcore import hooks @hooks.register('insert_editor_js') def enable_source(): return format_html(... |
[
"200, r.text assert r.json() == { \"notify_url\": \"/v2/notify\", \"subscriptions_url\": \"/v2/subscriptions\", \"entities_url\": \"/v2/entities\", \"types_url\":",
"requests.get('{}'.format(api_url)) assert r.status_code == 200, r.text assert r.json() == { \"notify_url\": \"/v2/notify\", \"subscriptions_url\":",... |
[
"d = step.runCommand(cmd) d.addCallback(lambda res: self.commandComplete(cmd)) return d def commandComplete(self, cmd): # False",
"to make a build step conditional to existence of some file. For example",
"existence on the worker. I return True if the file with the given",
"not any other file # system object.... |
[
"(env.compute_terminal(whos_turn=Color.Blue) is not WinEnum.NoWin) if current_episode.is_terminal:# Blue won the game! blue_won_the_game=True else: #####",
"EVALUATE) env.take_action(Color.Red, action_red) # take the action! current_episode.is_terminal = (env.compute_terminal(whos_turn=Color.Red) is not WinEnum.N... |
[
"generates the joint, outer and inner distributions. Attributes ---------- channel : core.Channel Channel",
"joint_t.T def _reduce_hyper(self): \"\"\"Given the hyper-distribution generated by _generate_posteriors remove columns with zeros",
"arange(self.inners.shape[1]): for j in arange(i+1, self.inners.shape[1... |
[
"- Control how the priority rule sets the priority of interfaces in the",
"health_check: \"<your_own_value> (source system.virtual-wan-link.health-check.name)\" id: \"102\" src: - name: \"default_name_104 (source firewall.address.name firewall.addrgrp.name)\"",
"str required: false username: description: - Fort... |
[
"print(\"Ahora estas en la habitacion\", habitacion.id) if habitacion.hijos[0] == None: pass else: if",
"self.lado1=None def get_abierta(self): return self.abierta def print_cosas(self): print(\"hola\") def set_abierta(self, value): self.abierta =",
"set_lado2(self, value): self.lado2 = value def espuerta(self)... |
[
"bounce_ball(self, ball): if self.collide_widget(ball): ball.velocity_x *= -1 print('hello world') class PongBall(Widget): velocity_x =",
"from random import randint class PongPaddle(Widget): score = NumericProperty(0) def bounce_ball(self, ball): if",
"PongGame(Widget): ball = ObjectProperty(None) player1 = Ob... |
[
"class SceneRelation: def __init__(self): self.on_ground = set() self.on_block = {} self.clear = set()",
"SceneRelation: def __init__(self): self.on_ground = set() self.on_block = {} self.clear = set() def",
"= set() self.on_block = {} self.clear = set() def print_relation(self): print(self.on_ground) print(sel... |
[
"0: opening_suit = card // 13 hands[player_idx].remove(card) cards_played.append(card) # Get the winning card.",
"they beat their partner? self.partner_win(valid_cards, agent_valid_cards, card, cards_played, partners_cards) \"\"\"''''''''''''''''''''''''''''''''''''''''''''''''''''''''' \" \" PLAY",
"== 12: p +... |
[
"hacs.hass = HomeAssistant() hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() await data.async_write() @pytest.mark.asyncio async",
"hacs.hass.config.config_dir = tmpdir hacs.configuration = Configuration() hacs.system.status.background_task = False hacs.system.disabled = False await",
... |