datamllab / rlcard / 252

Build # 252

Build Type

push

travis-ci

Committed by Daochen

Commit Message

<a href="https://github.com/datamllab/rlcard/commit/<a class=hub.com/datamllab/rlcard/commit/<a class="double-link" href="https://git"><a class=hub.com/datamllab/rlcard/commit/<a class="double-link" href="https://git"><a class=hub.com/datamllab/rlcard/commit/<a class="double-link" href="https://git"><a class=hub.com/datamllab/rlcard/commit/<a class="double-link" href="https://git"><a class=hub.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973">9f21c4d8d<a href="https://github.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973">&lt;a href=&quot;https://github.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973">&lt;a href=&quot;https://github.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973&amp;amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;Squashed commit of the following:

commit &amp;amp;lt;/a&amp;amp;gt;&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://github.com/datamllab/rlcard/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://github.com/datamllab/rlcard/commit/e681d505c21dd3d4fe975aced05a01a5f6ced7f2&amp;amp;quot;&amp;amp;gt;e681d505c&amp;amp;lt;/a&amp;amp;gt;&amp;amp;quot;&amp;amp;gt;e681d505c&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973&amp;quot;&amp;gt;
Author: Daochen &amp;amp;lt;daochen@datalab4.engr.tamu.edu&amp;amp;gt;
Date:   Wed Oct 9 08:57:36 2019 -0500

    docs

commit &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/datamllab/rlcard/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/datamllab/rlcard/commit/0a1e46b0ad17ef1c66cd5df4849ed23c0846763b&quot;&gt;0a1e46b0a&lt;/a&gt;&quot;&gt;0a1e46b0a&lt;/a&gt;&lt;a href=&quot;https://github.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973&quot;&gt;
Author: Daochen &amp;lt;daochen@datalab4.engr.tamu.edu&amp;gt;
Date:   Wed Oct 9 00:48:14 2019 -0500

    cfr doc

commit &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/datamllab/rlcard/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/datamllab/rlcard/commit/d7c07a8cbc16df8ff77d11d4dd1992deaa903e54&quot;&gt;d7c07a8cb&lt;/a&gt;&quot;&gt;d7c07a8cb&lt;/a&gt;&lt;a href="https://github.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973">
Author: Daochen &lt;daochen@datalab4.engr.tamu.edu&gt;
Date:   Tue Oct 8 23:34:14 2019 -0500

    setup version

commit </a><a class="double-link" href="https://github.com/datamllab/rlcard/commit/<a class="double-link" href="https://github.com/datamllab/rlcard/commit/2a84b1cd5ee5336b8531f6eea53774f73d42662c">2a84b1cd5</a>">2a84b1cd5</a><a href="https://github.com/datamllab/rlcard/commit/9f21c4d8d29c9e9e3f3bf5ab4852c67f09188973">
Author: songyih &lt;songyih1996@gmail.com&gt;
Date:   Tue Oct 8 20:05:34 2019 -0700

    learning curve

commit </a><a class="double-link" href="https://github.com/datamllab/rlcard/commit/<a class="double-link" href="https://github.com/datamllab/rlcard/commit/17594489955dd6bb2d4d2d1fb4feef01e6a146d4">175944899">175944899
Author: Kwei-Herng Lai <khlai037@datalab3.engr.tamu.edu>
Date:   Tue Oct 8 19:15:25 2019 -0700

    mahjong (readme)

commit 32abdb370">32abdb370</a>... (continued)

Run Details

1956 of 1956 new or added lines in 55 files covered. (100.0%)

3280 of 3422 relevant lines covered (95.85%)

0.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.49

/rlcard/games/doudizhu/utils.py

''' Doudizhu utils
'''

import os
import json
from collections import OrderedDict
import numpy as np

import rlcard

# Read required docs
ROOT_PATH = rlcard.__path__[0]

# a map of action to abstract action
with open(os.path.join(ROOT_PATH, 'games/doudizhu/jsondata/specific_map.json'), 'r') as file:
    SPECIFIC_MAP = json.load(file, object_pairs_hook=OrderedDict)

# a map of abstract action to its index and a list of abstract action
with open(os.path.join(ROOT_PATH, 'games/doudizhu/jsondata/action_space.json'), 'r') as file:
    ACTION_SPACE = json.load(file, object_pairs_hook=OrderedDict)
    ACTION_LIST = list(ACTION_SPACE.keys())

# a map of card to its type. Also return both dict and list to accelerate
with open(os.path.join(ROOT_PATH, 'games/doudizhu/jsondata/card_type.json'), 'r') as file:
    data = json.load(file, object_pairs_hook=OrderedDict)
    CARD_TYPE = (data, list(data), set(data))

# a map of type to its cards
with open(os.path.join(ROOT_PATH, 'games/doudizhu/jsondata/type_card.json'), 'r') as file:
    TYPE_CARD = json.load(file, object_pairs_hook=OrderedDict)

# rank list of solo character of cards
CARD_RANK_STR = ['3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K',
                 'A', '2', 'B', 'R']
# rank list
CARD_RANK = ['3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K',
             'A', '2', 'BJ', 'RJ']


def doudizhu_sort_str(card_1, card_2):
    ''' Compare the rank of two cards of str representation

    Args:
        card_1 (str): str representation of solo card
        card_2 (str): str representation of solo card

    Returns:
        int: 1(card_1 > card_2) / 0(card_1 = card2) / -1(card_1 < card_2)
    '''
    key_1 = CARD_RANK_STR.index(card_1)
    key_2 = CARD_RANK_STR.index(card_2)
    if key_1 > key_2:
        return 1
    if key_1 < key_2:
        return -1
    return 0


def doudizhu_sort_card(card_1, card_2):
    ''' Compare the rank of two cards of Card object

    Args:
        card_1 (object): object of Card
        card_2 (object): object of card
    '''
    key = []
    for card in [card_1, card_2]:
        if card.rank == '':
            key.append(CARD_RANK.index(card.suit))
        else:
            key.append(CARD_RANK.index(card.rank))
    if key[0] > key[1]:
        return 1
    if key[0] < key[1]:
        return -1
    return 0


def get_landlord_score(current_hand):
    ''' Roughly judge the quality of the hand, and provide a score as basis to
    bid landlord.

    Args:
        current_hand (str): string of cards. Eg: '56888TTQKKKAA222R'

    Returns:
        int: score
    '''
    score_map = {'A': 1, '2': 2, 'B': 3, 'R': 4}
    score = 0
    # rocket
    if current_hand[-2:] == 'BR':
        score += 8
        current_hand = current_hand[:-2]
    length = len(current_hand)
    i = 0
    while i < length:
        # bomb
        if i <= (length - 4) and current_hand[i] == current_hand[i+3]:
            score += 6
            i += 4
            continue
        # 2, Black Joker, Red Joker
        if current_hand[i] in score_map:
            score += score_map[current_hand[i]]
        i += 1
    return score


def get_optimal_action(probs, legal_actions):
    ''' Determine the optimal action from legal actions
    according to the probabilities of abstract actions.

    Args:
        probs (list): list of probabilities of abstract actions
        legal_actions (list): list of legal actions

    Returns:
        str: optimal legal action
    '''
    abstract_actions = [SPECIFIC_MAP[action] for action in legal_actions]
    action_probs = []
    for actions in abstract_actions:
        max_prob = -1
        for action in actions:
            prob = probs[ACTION_SPACE[action]]
            if prob > max_prob:
                max_prob = prob
        action_probs.append(max_prob)
    optimal_prob = max(action_probs)
    optimal_actions = [legal_actions[index] for index,
                       prob in enumerate(action_probs) if prob == optimal_prob]
    if len(optimal_actions) > 1:
        return np.random.choice(optimal_actions)
    return optimal_actions[0]


def cards2str(cards: list):
    ''' Get the corresponding string representation of cards

    Args:
        cards (list): list of Card objects

    Returns:
        string: string representation of cards
    '''
    response = ''
    for card in cards:
        if card.rank == '':
            response += card.suit[0]
        else:
            response += card.rank
    return response

def contains_cards(candidate, target):
    ''' Check if cards of candidate contains cards of target.

    Args:
        candidate (string): A string representing the cards of candidate
        target (string): A string representing the number of cards of target

    Returns:
        boolean
    '''
    len_can = len(candidate)
    len_tar = len(target)
    if len_can < len_tar:
        return False
    if len_can == len_tar:
        if candidate == target:
            return True
        return False
    beg = 0
    for tar_card in target:
        beg = candidate.find(tar_card, beg) + 1
        if beg == 0:
        #if tar_card not in candidate:
            return False
    return True

def encode_cards(plane, cards):
    ''' Encode cards and represerve it into plane.

    Args:
        cards (list or str): list or str of cards, every entry is a
    character of solo representation of card
    '''
    if not cards:
        return None
    layer = 1
    if len(cards) == 1:
        rank = CARD_RANK_STR.index(cards[0])
        plane[layer][rank] = 1
        plane[0][rank] = 0
    else:
        for index, card in enumerate(cards):
            if index == 0:
                continue
            if card == cards[index-1]:
                layer += 1
            else:
                rank = CARD_RANK_STR.index(cards[index-1])
                plane[layer][rank] = 1
                layer = 1
                plane[0][rank] = 0
        rank = CARD_RANK_STR.index(cards[-1])
        plane[layer][rank] = 1
        plane[0][rank] = 0


def get_gt_cards(player, greater_player):
    ''' Provide player's cards which are greater than the ones played by
    previous player in one round

    Args:
        player (DoudizhuPlayer object): the player waiting to play cards
        greater_player (DoudizhuPlayer object): the player who played current biggest cards.

    Returns:
        list: list of string of greater cards

    Note:
        1. return value contains 'pass'
    '''
    # add 'pass' to legal actions
    gt_cards = ['pass']
    current_hand = cards2str(player.current_hand)
    target_cards = greater_player.played_cards
    target_types = CARD_TYPE[0][target_cards]
    type_dict = {}
    for card_type, weight in target_types:
        if card_type not in type_dict:
            type_dict[card_type] = weight
    if 'rocket' in type_dict:
        return gt_cards
    type_dict['rocket'] = -1
    if 'bomb' not in type_dict:
        type_dict['bomb'] = -1
    for card_type, weight in type_dict.items():
        candidate = TYPE_CARD[card_type]
        for can_weight, cards_list in candidate.items():
            if int(can_weight) > weight:
                for cards in cards_list:
                    # TODO: improve efficiency
                    if cards not in gt_cards and contains_cards(current_hand, cards):
                    # if self.contains_cards(current_hand, cards):
                        gt_cards.append(cards)
    return gt_cards


# Test json order
#if __name__ == '__main__':
#    for action, index in ACTION_SPACE.items():
#        if action != ACTION_LIST[index]:
#            print('order error')

1	''' Doudizhu utils
2	'''
3
4	import os	1✔
5	import json	1✔
6	from collections import OrderedDict	1✔
7	import numpy as np	1✔
8
9	import rlcard	1✔
10
11	# Read required docs
12	ROOT_PATH = rlcard.__path__[0]	1✔
13
14	# a map of action to abstract action
15	with open(os.path.join(ROOT_PATH, 'games/doudizhu/jsondata/specific_map.json'), 'r') as file:	1✔
16	SPECIFIC_MAP = json.load(file, object_pairs_hook=OrderedDict)	1✔
17
18	# a map of abstract action to its index and a list of abstract action
19	with open(os.path.join(ROOT_PATH, 'games/doudizhu/jsondata/action_space.json'), 'r') as file:	1✔
20	ACTION_SPACE = json.load(file, object_pairs_hook=OrderedDict)	1✔
21	ACTION_LIST = list(ACTION_SPACE.keys())	1✔
22
23	# a map of card to its type. Also return both dict and list to accelerate
24	with open(os.path.join(ROOT_PATH, 'games/doudizhu/jsondata/card_type.json'), 'r') as file:	1✔
25	data = json.load(file, object_pairs_hook=OrderedDict)	1✔
26	CARD_TYPE = (data, list(data), set(data))	1✔
27
28	# a map of type to its cards
29	with open(os.path.join(ROOT_PATH, 'games/doudizhu/jsondata/type_card.json'), 'r') as file:	1✔
30	TYPE_CARD = json.load(file, object_pairs_hook=OrderedDict)	1✔
31
32	# rank list of solo character of cards
33	CARD_RANK_STR = ['3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K',	1✔
34	'A', '2', 'B', 'R']
35	# rank list
36	CARD_RANK = ['3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K',	1✔
37	'A', '2', 'BJ', 'RJ']
38
39
40	def doudizhu_sort_str(card_1, card_2):	1✔
41	''' Compare the rank of two cards of str representation
42
43	Args:
44	card_1 (str): str representation of solo card
45	card_2 (str): str representation of solo card
46
47	Returns:
48	int: 1(card_1 > card_2) / 0(card_1 = card2) / -1(card_1 < card_2)
49	'''
50	key_1 = CARD_RANK_STR.index(card_1)	1✔
51	key_2 = CARD_RANK_STR.index(card_2)	1✔
52	if key_1 > key_2:	1✔
53	return 1	1✔
54	if key_1 < key_2:	1✔
55	return -1	1✔
56	return 0	1✔
57
58
59	def doudizhu_sort_card(card_1, card_2):	1✔
60	''' Compare the rank of two cards of Card object
61
62	Args:
63	card_1 (object): object of Card
64	card_2 (object): object of card
65	'''
66	key = []	1✔
67	for card in [card_1, card_2]:	1✔
68	if card.rank == '':	1✔
69	key.append(CARD_RANK.index(card.suit))	1✔
70	else:
71	key.append(CARD_RANK.index(card.rank))	1✔
72	if key[0] > key[1]:	1✔
73	return 1	1✔
74	if key[0] < key[1]:	1✔
75	return -1	1✔
76	return 0	1✔
77
78
79	def get_landlord_score(current_hand):	1✔
80	''' Roughly judge the quality of the hand, and provide a score as basis to
81	bid landlord.
82
83	Args:
84	current_hand (str): string of cards. Eg: '56888TTQKKKAA222R'
85
86	Returns:
87	int: score
88	'''
89	score_map = {'A': 1, '2': 2, 'B': 3, 'R': 4}	1✔
90	score = 0	1✔
91	# rocket
92	if current_hand[-2:] == 'BR':	1✔
93	score += 8	×
94	current_hand = current_hand[:-2]	×
95	length = len(current_hand)	1✔
96	i = 0	1✔
97	while i < length:	1✔
98	# bomb
99	if i <= (length - 4) and current_hand[i] == current_hand[i+3]:	1✔
100	score += 6	×
101	i += 4	×
102	continue	×
103	# 2, Black Joker, Red Joker
104	if current_hand[i] in score_map:	1✔
105	score += score_map[current_hand[i]]	1✔
106	i += 1	1✔
107	return score	1✔
108
109
110	def get_optimal_action(probs, legal_actions):	1✔
111	''' Determine the optimal action from legal actions
112	according to the probabilities of abstract actions.
113
114	Args:
115	probs (list): list of probabilities of abstract actions
116	legal_actions (list): list of legal actions
117
118	Returns:
119	str: optimal legal action
120	'''
121	abstract_actions = [SPECIFIC_MAP[action] for action in legal_actions]	1✔
122	action_probs = []	1✔
123	for actions in abstract_actions:	1✔
124	max_prob = -1	1✔
125	for action in actions:	1✔
126	prob = probs[ACTION_SPACE[action]]	1✔
127	if prob > max_prob:	1✔
128	max_prob = prob	1✔
129	action_probs.append(max_prob)	1✔
130	optimal_prob = max(action_probs)	1✔
131	optimal_actions = [legal_actions[index] for index,	1✔
132	prob in enumerate(action_probs) if prob == optimal_prob]
133	if len(optimal_actions) > 1:	1✔
134	return np.random.choice(optimal_actions)	×
135	return optimal_actions[0]	1✔
136
137
138	def cards2str(cards: list):	1✔
139	''' Get the corresponding string representation of cards
140
141	Args:
142	cards (list): list of Card objects
143
144	Returns:
145	string: string representation of cards
146	'''
147	response = ''	1✔
148	for card in cards:	1✔
149	if card.rank == '':	1✔
150	response += card.suit[0]	1✔
151	else:
152	response += card.rank	1✔
153	return response	1✔
154
155	def contains_cards(candidate, target):	1✔
156	''' Check if cards of candidate contains cards of target.
157
158	Args:
159	candidate (string): A string representing the cards of candidate
160	target (string): A string representing the number of cards of target
161
162	Returns:
163	boolean
164	'''
165	len_can = len(candidate)	1✔
166	len_tar = len(target)	1✔
167	if len_can < len_tar:	1✔
168	return False	1✔
169	if len_can == len_tar:	1✔
170	if candidate == target:	1✔
171	return True	1✔
172	return False	1✔
173	beg = 0	1✔
174	for tar_card in target:	1✔
175	beg = candidate.find(tar_card, beg) + 1	1✔
176	if beg == 0:	1✔
177	#if tar_card not in candidate:
178	return False	1✔
179	return True	1✔
180
181	def encode_cards(plane, cards):	1✔
182	''' Encode cards and represerve it into plane.
183
184	Args:
185	cards (list or str): list or str of cards, every entry is a
186	character of solo representation of card
187	'''
188	if not cards:	1✔
189	return None	1✔
190	layer = 1	1✔
191	if len(cards) == 1:	1✔
192	rank = CARD_RANK_STR.index(cards[0])	1✔
193	plane[layer][rank] = 1	1✔
194	plane[0][rank] = 0	1✔
195	else:
196	for index, card in enumerate(cards):	1✔
197	if index == 0:	1✔
198	continue	1✔
199	if card == cards[index-1]:	1✔
200	layer += 1	1✔
201	else:
202	rank = CARD_RANK_STR.index(cards[index-1])	1✔
203	plane[layer][rank] = 1	1✔
204	layer = 1	1✔
205	plane[0][rank] = 0	1✔
206	rank = CARD_RANK_STR.index(cards[-1])	1✔
207	plane[layer][rank] = 1	1✔
208	plane[0][rank] = 0	1✔
209
210
211	def get_gt_cards(player, greater_player):	1✔
212	''' Provide player's cards which are greater than the ones played by
213	previous player in one round
214
215	Args:
216	player (DoudizhuPlayer object): the player waiting to play cards
217	greater_player (DoudizhuPlayer object): the player who played current biggest cards.
218
219	Returns:
220	list: list of string of greater cards
221
222	Note:
223	1. return value contains 'pass'
224	'''
225	# add 'pass' to legal actions
226	gt_cards = ['pass']	1✔
227	current_hand = cards2str(player.current_hand)	1✔
228	target_cards = greater_player.played_cards	1✔
229	target_types = CARD_TYPE[0][target_cards]	1✔
230	type_dict = {}	1✔
231	for card_type, weight in target_types:	1✔
232	if card_type not in type_dict:	1✔
233	type_dict[card_type] = weight	1✔
234	if 'rocket' in type_dict:	1✔
235	return gt_cards	1✔
236	type_dict['rocket'] = -1	1✔
237	if 'bomb' not in type_dict:	1✔
238	type_dict['bomb'] = -1	1✔
239	for card_type, weight in type_dict.items():	1✔
240	candidate = TYPE_CARD[card_type]	1✔
241	for can_weight, cards_list in candidate.items():	1✔
242	if int(can_weight) > weight:	1✔
243	for cards in cards_list:	1✔
244	# TODO: improve efficiency
245	if cards not in gt_cards and contains_cards(current_hand, cards):	1✔
246	# if self.contains_cards(current_hand, cards):
247	gt_cards.append(cards)	1✔
248	return gt_cards	1✔
249
250
251	# Test json order
252	#if __name__ == '__main__':
253	# for action, index in ACTION_SPACE.items():
254	# if action != ACTION_LIST[index]:
255	# print('order error')

datamllab / rlcard / 252

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous