def load_chain(self, filepath, key): print(filepath, key) c = Chain() with open(filepath) as f: for line in f: c.grow(line.split()) self.cache[key] = c
def test_generate(): c = Chain() c.grow(s1) c.grow(s2) for i in range(10): print('%s.' % ' '.join(c.generate()))
def test_generate_rms(): c = Chain() d = os.path.dirname(__file__) filename = os.path.join(d, 'files/rms.txt') with open(filename, 'r') as f: content = f.read() for sentence in content.split('.'): words = sentence.split() c.grow(words) for i in range(10): print('%s.' % ' '.join(c.generate()))
def __init__(self): """Reads in phonetic data and creates a markov chain""" data = [] for x in open('data/phonmap.txt').readlines(): data.extend(x.split()) #Build up a markov chain with it self.chain = Chain(data, 2)
def build_chain(db, max_comments=None): c = Chain(tokenizer=markdown_tokenizer(), N=10) comment_count = len(db) if max_comments: comment_count = min(comment_count, max_comments) for index, comment_id in enumerate(db): body = db[comment_id]['body'] c.train(body) set_line('Loaded %s/%s comments...' % (index + 1, comment_count)) if max_comments and index + 1 >= max_comments: break set_line('') return c
def build_chain(db, max_comments=None): c = Chain(tokenizer=markdown_tokenizer(), N=10) comment_count = len(db) if max_comments: comment_count = min(comment_count, max_comments) for index, comment_id in enumerate(db): body = db[comment_id]['body'] c.train(body) set_line('Loaded %s/%s comments...' % (index+1, comment_count)) if max_comments and index+1 >= max_comments: break set_line('') return c
def test_save(tmp_file): c = Chain() c.grow(s1) c.grow(s2) c.save(tmp_file) c = load(tmp_file) for i in range(10): print('%s.' % ' '.join(c.generate()))
class WordGen(object): def __init__(self): """Reads in phonetic data and creates a markov chain""" data = [] for x in open('data/phonmap.txt').readlines(): data.extend(x.split()) #Build up a markov chain with it self.chain = Chain(data, 2) def make_word(self): """Constructs words""" fragments = self.chain.generate(random.randint(2, 6)) return "".join(fragments)
def test_grow(): c = Chain() c.grow(s1) for w in s1: assert w in c.words assert len(c.words) == 3 c.grow(s2) for w in s2: assert w in c.words assert len(c.words) == 5
class ShaqFu(object): def __init__(self): data = open('training_data.txt').read() self.chain = Chain(tokens(data), 5) def generate_line(self, rhymes): words = self.chain.generate(100) lines = ' '.join([x for x in words]).splitlines(False) return random.choice(lines) def generate_chorus(self): return ['[CHORUS]'] + [self.generate_line(True) for x in xrange(5)] + ['\n'] def generate_verse(self, min_length, max_length): length = random.randint(min_length, max_length) return ['[VERSE]'] + [self.generate_line(False) for x in xrange(length)] + ['\n'] def generate_song(self): chorus = self.generate_chorus() verses = [self.generate_verse(5, 10) for x in xrange(3)] return verses[0] + chorus + verses[1] + chorus + verses[2]
#!/usr/bin/env python3 from lxml import html from bs4 import BeautifulSoup import requests from markov import Chain simpsons_synopsis = Chain(2) for year in range(1990, 2017): url_base = 'http://www.imdb.com/title/tt0096697/episodes?year=' page = requests.get(url_base + str(year)) soup = BeautifulSoup(page.content, "lxml") item_divs = soup.find_all("div", class_="item_description") descriptions = [ div.string.strip() for div in item_divs if div.string is not None ] for desc in descriptions: simpsons_synopsis.add_passage(desc) for i in range(10): print(' '.join(simpsons_synopsis.simulate()))
# secret.json is: { # twitter: { # key, keysecret, token, tokensecret # } # } secret = json.load(open('secret.json'))['twitter'] auth = tweepy.OAuthHandler(secret['key'], secret['keysecret']) auth.set_access_token(secret['token'], secret['tokensecret']) twitter = tweepy.API(auth) dedupe = json.load(open('dedupe.json')) or {} try: chain = Chain(json.load(open('chains/trumpov_2.json'))) post = None i = 0 while (not post) or (post in dedupe): post = chain.gen(1000) i += 1 if i >= 20: raise Exception('too many duplicates') twitter.update_status(html.unescape(post)) dedupe[post] = True json.dump(dedupe, open('dedupe.json', 'w')) print('success') except Exception as ex: print('failed') print(ex)
#!coding:utf-8 from random import random from graphviz import Digraph from markov import Chain from markov.plot import transitions_to_graph def double_dice(): return int(random() * 6) + int(random() * 6) chain = Chain(11, double_dice()) # flip coin many times and build Markov chain for this process # let 0 be heads and 1 tails for i in range(1000000): chain.learn(double_dice()) g = Digraph(format='svg', engine='dot', graph_attr={ 'overlap': 'false', 'pad': '0.1', 'nodesep': '0.35', 'ranksep': '0.35' }, edge_attr={ 'fontname': 'Helvetica', 'fontsize': '8.0'
"--token", type=str, default=get_token(), help="The Discord token for your bot.", ) parser.add_argument( "-p", "--persist", type=Path, default=Path("model.json"), help="The file path for storing the model persistently.", ) args = parser.parse_args() chain = Chain(1) if args.persist.exists(): chain.deserialize(args.persist.read_text()) chain_lock = asyncio.Lock() client = discord.Client() @client.event async def on_ready(): print(f"Logged on as {client.user}.") @client.event async def on_message(message): async with chain_lock:
def main(text_list, order): chain = Chain(order, text_list) # return chain.sample(10, 'rat-faced') # print(chain) return chain.sample(5)
def main(): chain = Chain(tokens(poem), 4) words = chain.generate(2000) print "".join([x for x in words])
def test_moving_stochastically_adds_new_state(self): chain = Chain(self.model) chain.move() self.assertEqual(len(chain.states), 1)
def __init__(self): data = open('training_data.txt').read() self.chain = Chain(tokens(data), 5)
def test_moving_to_specific_state_from_empty(self): chain = Chain(self.model) chain.move_to("a") self.assertEqual(chain.states, ["a"])
#!coding:utf-8 from random import betavariate from graphviz import Digraph from markov import Chain from markov.plot import transitions_to_graph def rigged_dice(): return int((betavariate(0.5, 0.7) * 6)) chain = Chain(6, rigged_dice()) # roll dice many times and build Markov chain for this process for i in range(100000): chain.learn(rigged_dice()) def state_mapping(state): if state == 0: return u'⚀' if state == 1: return u'⚁' if state == 2: return u'⚂' if state == 3: return u'⚃' if state == 4: return u'⚄' if state == 5: return u'⚅' g = Digraph(format='svg', engine='dot', graph_attr={'pad': '0.1', 'nodesep': '0.15', 'ranksep': '0.5'},