Beispiel #1
0
    def runIters(procNum):
        ITERATIONS = 100
        guessesToWin = []
        losses = 0

        for i in range(ITERATIONS):
            guesser = Guesser()
            guesser.weightingTuple = weightTuple

            responder = Responder(
                getCellTuple(n2l(random.randint(1, 18)), random.randint(1,
                                                                        18)))
            # print(f"Iteration {i}: {formatCell(responder.cell)}")

            turns = 0
            gameOver = False

            while not gameOver:
                guess = guesser.getGuess()
                # print(f"Turn {turns} of iteration {i}: {formatCell(guess[0])}")
                if guess[1]:
                    if responder.checkSolve(guess[0]):
                        guessesToWin.append(turns)
                        break
                    else:
                        losses += 1
                        break

                guesser.feedback(guess[0], responder.check(guess[0]))
                turns += 1

        return (guessesToWin, losses, ITERATIONS)
Beispiel #2
0
def create_guess_game():
    """ Define game logic"""
    your_name = input("Hello! What's your name?\n")
    guesser = Guesser()
    max_d = Guesser.get_max_difficulty()
    min_d = Guesser.get_min_difficulty()
    guess = False

    while not guess:
        difficulty = input(
            f"{your_name}, choose a difficulty between {max_d} and {min_d}  ")
        guess = guesser.choose_challenge_level(difficulty)

    print(
        f'Well, {your_name} I am thinking of a number between {Guesser.min_range} and {Guesser.max_range}'
    )

    run = True
    count = 0

    while run:
        user_guess = input(f"{your_name}, take a guess:   ")
        count += 1
        run = guesser.run_game(user_guess, count)
        if guesser.status == -1:
            print("Your guess is too low\n")
        if guesser.status == 1:
            print("Your guess is too high\n")

    if guesser.status == 0:
        print(
            f"Good Job {your_name} You guessed my number in {count} guesses!")
    else:
        print(
            f"{your_name}, you've lost. My number was {guesser.guess_number}")
Beispiel #3
0
    def __init__(self,
                 beam=1000,
                 max_guess=20,
                 rare_treshold=10,
                 capitalization=True):
        self._uni = FreqDist()
        self._bi = ConditionalFreqDist()
        self._tri = ConditionalFreqDist()

        self._wd = ConditionalFreqDist()

        self._l1 = 0.0
        self._l2 = 0.0
        self._l3 = 0.0

        self._beam_size = beam
        self._use_capitalization = capitalization
        self._max_guess = max_guess
        self._treshold = rare_treshold

        self._unk = Guesser(10)
        self._analyzer = None
        self.cache = {}
Beispiel #4
0
from manualfeedbacker import ManualFeedbacker
from guesser import Guesser

print("Welcome, im a masterminded bot.")

guesser = Guesser(ManualFeedbacker())
solutionString = guesser.solve()

print("Well it seems like i've found the solution. It's: " + solutionString)

print("Goodbye you fool! ;)")
#!/usr/bin/env python3

import random
import sys

from guesser import FitnessGuesser as Guesser
from helpers import getCellTuple, n2l, formatCell

guesser = Guesser()
print(f"Board initialized; {len(guesser.board)} possibilities remain")

while True:
    guess = guesser.getGuess()

    if guess[1]:
        print("Making solve attempt!")
        print(formatCell(guess[0]))
        break

    response = input(formatCell(guess[0]) + '? ')
    guesser.feedback(guess[0], response.upper() in ['Y', 'YES'])

    print(f"{len(guesser.board)} possibilities remain")
Beispiel #6
0
 def setUpClass(cls):
     cls.guesser = Guesser()
Beispiel #7
0
class MorphProbModel():
    UNK_PROB = -99

    def __init__(self,
                 beam=1000,
                 max_guess=20,
                 rare_treshold=10,
                 capitalization=True):
        self._uni = FreqDist()
        self._bi = ConditionalFreqDist()
        self._tri = ConditionalFreqDist()

        self._wd = ConditionalFreqDist()

        self._l1 = 0.0
        self._l2 = 0.0
        self._l3 = 0.0

        self._beam_size = beam
        self._use_capitalization = capitalization
        self._max_guess = max_guess
        self._treshold = rare_treshold

        self._unk = Guesser(10)
        self._analyzer = None
        self.cache = {}

    def set_analyzer(self, obj):
        self._analyzer = obj

    def train(self, data):
        C = False
        for sent in data:
            history = [('BOS', False), ('BOS', False)]
            for w, l, t in sent:
                # Ezt azért szedtem ki mert megeszik 4 giga memóriát ha marad
                # t = encode((w, l, t))
                if self._use_capitalization and w[0].isupper():
                    C = True

                self._wd[w].inc(t)
                self._uni.inc((t, C))
                self._bi[history[1]].inc((t, C))
                self._tri[tuple(history)].inc((t, C))

                history.append((t, C))
                history.pop(0)

                C = False

        for word, fd in self._wd.iteritems():
            for tag, count in  fd.iteritems():
                if count < self._treshold:
                    self._unk.add_word(word.lower(), tag, count)
        self._unk.finalize()

        self._compute_lambda()

    def _compute_lambda(self):
        tl1 = 0.0
        tl2 = 0.0
        tl3 = 0.0

        for history in self._tri.conditions():
            (h1, h2) = history

            for tag in self._tri[history].samples():

                if self._uni[tag] == 1:
                    continue

                c3 = self._safe_div((self._tri[history][tag] - 1),
                                    (self._tri[history].N() - 1))
                c2 = self._safe_div((self._bi[h2][tag] - 1),
                                    (self._bi[h2].N() - 1))
                c1 = self._safe_div((self._uni[tag] - 1), (self._uni.N() - 1))

                if (c1 > c3) and (c1 > c2):
                    tl1 += self._tri[history][tag]

                elif (c2 > c3) and (c2 > c1):
                    tl2 += self._tri[history][tag]

                elif (c3 > c2) and (c3 > c1):
                    tl3 += self._tri[history][tag]

                elif (c3 == c2) and (c3 > c1):
                    tl2 += float(self._tri[history][tag]) / 2.0
                    tl3 += float(self._tri[history][tag]) / 2.0

                elif (c2 == c1) and (c1 > c3):
                    tl1 += float(self._tri[history][tag]) / 2.0
                    tl2 += float(self._tri[history][tag]) / 2.0

                else:
                    pass

        self._l1 = tl1 / (tl1 + tl2 + tl3)
        self._l2 = tl2 / (tl1 + tl2 + tl3)
        self._l3 = tl3 / (tl1 + tl2 + tl3)

    def _safe_div(self, v1, v2):
        if v2 == 0:
            return -1
        else:
            return float(v1) / float(v2)

    def _transition_prob(self, t, C, history):
        p_uni = self._uni.freq((t, C))
        p_bi = self._bi[history[-1]].freq((t, C))
        p_tri = self._tri[tuple(history[-2:])].freq((t, C))
        p = self._l1 * p_uni + self._l2 * p_bi + self._l3 * p_tri
        if p == 0.0:
            return self.UNK_PROB
        return log(p, 2)

    def _known_lexical_prob(self, word, t, C):
        p = float(self._wd[word][t]) / float(self._uni[(t, C)])
        return log(p, 2)

    def _analyze(self, word):
        tag_candidates = []
        if word in self._wd.conditions():
            tag_candidates = set(self._wd[word].samples())
        else:
            analyses = map(itemgetter(1), self._analyzer.analyze(word))
            guesses = self._unk.get_probs(word.lower())
            guesses = map(itemgetter(0),
                          sorted(guesses.iteritems(), reverse=True,
                     key=itemgetter(1))[:self._max_guess])
            tag_candidates = set(guesses)
            if analyses:
                tag_candidates &= set(analyses)
            if not tag_candidates:
                tag_candidates = set(guesses)
        return tag_candidates

    def _lexical_prob(self, word, t, C):
        if word in self._wd.conditions():
            return self._known_lexical_prob(word, t, C)
        else:
            return self._unk.get_prob(word, t)

    def tag(self, sent, n=5):
        current_state = [(['BOS', 'BOS'], 0.0)]
        out = self._tagword(sent, current_state, n)
        return out

    def _tagword(self, sent, current_states, n=5):
        # A cache-sel elég gyors. Nem érdemes jobban vesződni vele.
        if sent == []:
            # yield ...
            return [(map(itemgetter(0), tag_seq[0][2:]),
                          tag_seq[1]) for tag_seq in current_states[:n]]

        word = sent[0]
        sent = sent[1:]
        new_states = []

        # Cache lookup
        sent_str = word + str(current_states)
        if sent_str in self.cache:
            return self._tagword(sent, self.cache[sent_str], n)

        C = False
        if self._use_capitalization and word[0].isupper():
            C = True

        analyses = self._analyze(word)

        for (history, curr_sent_logprob) in current_states:
            logprobs = []

            for t in analyses:

                p_t = self._transition_prob(t, C, history)
                p_l = self._lexical_prob(word, t, C)

                p = p_t + p_l

                logprobs.append(((t, C), p))

            for (tag, logprob) in logprobs:
                new_states.append((history + [tag],
                                   curr_sent_logprob + logprob))

        new_states.sort(reverse=True, key=itemgetter(1))

        if len(new_states) > self._beam_size:
            new_states = new_states[:self._beam_size]

        # Cache store
        self.cache[sent_str] = new_states

        # yield new_states
        # self._tagword(sent, new_states, n)
        return self._tagword(sent, new_states, n)
Beispiel #8
0
from token import Token
from guesser import Guesser

#init
guesser = Guesser()
token = Token()

for times in range(1):
  guesser.reset()
  token.getNewToken()
  token.printToken()

  guessCount = 0
  while token.status == 'ALIVE':
    guess = guesser.makeGuess(token.state)
    print 'Guess: ' + guess
    token.guess (guess)
    token.printToken()
    guessCount += 1

  print 'Total guesses: ' + str(guessCount)
  print '+'*60