def cost_per_period(States,Actions,dict_states, args, index_LT): P = TransitionProbs(States, Actions, args.Demand_Max, args.LT_s, args.LT_f, args.h, args.b, args.C_s, args.C_f, args.Inv_Max, args.Inv_Min, args.cap_fast, args.cap_slow, dict_states) start = time.time() env = PI_env(States, Actions, P) #print('env created', time.time() - start) policy, v = policy_improvement(env, args.discount_factor) #print(time.time() - start) #print("Policy Probability Distribution:") #print(policy) #print("") #print("Value Function:") #print(v) #print("") np.savetxt("policy-LT%i-cap%i.csv" %(index_LT,args.cap_fast), policy, delimiter=";") np.savetxt("valuefunction-LT%i-cap%i.csv"%(index_LT,args.cap_fast), v, delimiter=";") np.savetxt("States-LT%i-cap%i.csv"%(index_LT,args.cap_fast),States, delimiter=";") np.savetxt("Actions-LT%i-cap%i.csv"%(index_LT,args.cap_fast), Actions, delimiter=";") #for index, i in enumerate(States): # print(i, Actions[np.argmax(policy[index])]) MC, MC_R = MarkovChain.MC(States, P, policy) steady_state = MarkovChain.steady_state(States, policy, MC) #print(steady_state) optimal_cost = MarkovChain.cost_steady_state(steady_state, policy, MC, MC_R) return optimal_cost
class MarkovWordGenerator: """ This class builds a Markov chain out of some input text and spits out something that is hopefully intelligible.""" def __init__(self, inputText, n=1): inputText = string.replace(inputText, "\n"," ") self._inputText = string.split(inputText, " ") # Remove blanks from the list try: while 1: self._inputText.remove('') except ValueError: pass # allow for circular treatment of text, so that every # state will lead to at least one other state self._inputText = self._inputText + self._inputText[0:n+1] self._n = n self._markovChain = MarkovChain() self.__buildMarkovChain() def __buildMarkovChain(self): # Build a Markov chain with each set of adjacent n words # representing a state in the chain. nGram1 = tuple(self._inputText[0: self._n]) i = 1 # Cycle through the n-grams in the text and add each n-gram, # along with adjacent n-grams, to the markov chain. while i < (len(self._inputText) - self._n): nGram2 = tuple(self._inputText[i: i + self._n]) self._markovChain.add(nGram1, nGram2) nGram1 = nGram2 i = i + 1 def generate(self, numWords, method = MarkovChain.MOST_LIKELY): # Generate numWords words based on the Markov Chain model. # Randomly pick the first word generated r = randint(0, len(self._inputText) - (self._n + 1)) state = tuple(self._inputText[r: r + self._n]) outputText = string.join([word for word in state], " ") # Output each new word based on the previous state for i in range(numWords): state = self._markovChain.next(state, method) outputText = outputText + ' ' + state[-1] return outputText
def strat_markov_chain(play): """You can copy and modify this strategy.""" ret_val = result.Result() for act in play.gen_acts(): for scene in act.gen_scenes(): ret_val.set_act_scene(act, scene) mc = MarkovChain.MarkovChain() actors_seen = [] while True: # Ask the markov chain for the most likely guess if len(actors_seen): most_probable = mc.most_probable(actors_seen[-1]) else: most_probable = tuple() # If multiple values choose one randomly if len(most_probable) > 1: my_choice = random.choice(most_probable) elif len(most_probable) == 1: my_choice = most_probable[0] else: # Not enough information my_choice = '' actual_actor = ret_val.guess(my_choice) if actual_actor is None: break else: # Record the transition if len(actors_seen): mc.add(actors_seen[-1], actual_actor) actors_seen.append(actual_actor) return ret_val
def chainBuilder(self): parsedEpisodes = getEpisodes(self.episodes) for e in parsedEpisodes: castList = e.getCast() for c in castList: if c not in self.suppCharacters and c not in self.mainCharacters: self.suppCharacters.add(c) directChain = MarkovChain(2) #Change direction order here stageDirections = getAllStageDirs(self.episodes) for direction in stageDirections: directChain.addData(direction.getChainableSource()) self.chains["STAGEDIR"] = directChain for i in self.mainCharacters: self.characterChain(i) for m in self.suppCharacters: self.characterChain(m)
def MarkovTrumpReactiveTweetGen(inp): ret = "" chain = MarkovChain.MarkovChain(csvParser.ImportTrumpData()) if (inp == ''): ret = MarkovTweetGen(chain) else: ret = MarkovReactiveTweetGen(chain, inp) if (ret.endswith(',')): ret = ret[0:-1] if (not (ret.endswith(".")) and not (ret.endswith("!")) and not (ret.endswith("?"))): ret += '.' return ret
def __init__(self): self.memory = [] self.markov_graph = MarkovChain.MarkovChain() self.active_input_pattern_index = -1 self.prev_active_input_pattern_index = -1 self.temporal_groups = [] self.active_temporal_group_index = -1 # In the format (x1, y1, x2, y2) where (x1, y1) is the top left of the rectangle # and (x2, y2) is the bottom right of the rectangle. All rectangles are in the 4th # quadrant of the Euclidean plane where the negative y axis is positive. self.receptive_field_dimensions = None
def __init__(self, inputText, n=1): inputText = string.replace(inputText, "\n"," ") self._inputText = string.split(inputText, " ") # Remove blanks from the list try: while 1: self._inputText.remove('') except ValueError: pass # allow for circular treatment of text, so that every # state will lead to at least one other state self._inputText = self._inputText + self._inputText[0:n+1] self._n = n self._markovChain = MarkovChain() self.__buildMarkovChain()
if not channel: channel = input("Channel: ") if not dict_name: print("No dict name specified. Setting it to channel name.") dict_name = channel username = "" auth_token = "" with open("creds.txt", 'r') as creds_file: username = creds_file.readline() auth_token = creds_file.readline() irc_bot = TwitchChat.TwitchChat(username, auth_token, channel) markov_chain = MarkovChain.MarkovChain(save_dir, dict_name) while True: msg = irc_bot.next_msg() if msg: markov_chain.take_message(msg) if markov_chain.iterations() % 5 == 1: print("Channel:", markov_chain.dict_name) print("Iterations:", markov_chain.iterations()) print("Time elapsed:", int(markov_chain.time_elapsed()), "seconds") print("Message:", markov_chain.make_message()) print() markov_chain.save_progress()
with open("data_repo/data.json") as json_data: trump_data = json.load(json_data) json_data.close() # apparently have to download this data set to build the tokenizer nltk.download('punkt') speech_text = PreProcess.bulk_txt_load('data_repo/*.txt') text_extract = [x['text'] for x in trump_data] text_extract.extend(speech_text) # join all the tweets together into one long tweet corpus = ' '.join(text_extract) tokens = corpus.split(" ") # bigrams = nltk.ngrams(tokens,2) # trigrams = nltk.ngrams(tokens,3) # # ngram_list = [ item for item in ngrams] # mc = MarkovChain.MarkovModel() #mc_model = mc.build_model(bigrams) mc_model2 = mc.learn(tokens, 2) output = mc.generate(2, max_tokens=125) print(' '.join(output) + '.')
word1 = inp retSen = word1.capitalize() else: if (inp.endswith('s')): word1 = "are" else: word1 = "is" retSen = inp.capitalize() + ' ' + word1 for it in range(length - 1): word2 = random.choice(MC[word1]) # Check for custom end of tweet token if (word2 == "@b@"): break word1 = word2 retSen += " " + word1 if (not (retSen.endswith(".")) and not (retSen.endswith("!")) and not (retSen.endswith("?"))): retSen += '.' print(retSen) return retSen if (__name__ == "__main__"): #TweetCreator(input1) chain = MarkovChain.MarkovChain(csvParser.ImportTrumpData()) for it in range(10): print("Test #" + str(it) + ':') MarkovTrumpReactiveTweetGen("")
from MarkovChain import * m = MarkovChain() m.transition_table = [[0.9, 0.05, 0.05], [0.5, 0.1, 0.4], [0, 1, 0]] m.nodes = ["alive", "zombie", "dead"] for i in m.generator(): print(i)
default=0.99, type=float, help="discount_factor. Default = 0.99", dest="discount_factor") args = parser.parse_args() #DP(args,8) States = environment.CreateStates(args.LT_f, args.LT_s, args.Inv_Max, args.Inv_Min, args.OrderFast, args.OrderSlow) Actions = environment.CreateActions(args.OrderFast, args.OrderSlow) dict_states = environment.CreateDictStates(States) with open('./A3C_policy.csv') as f: #States = [] policy = [] for line in f: #States.append(line.split(sep=';')[:2]) policy.append(line.split(sep=';')[0:82]) #a_prob_s.append(line.split(sep=';')[10:16]) for index, i in enumerate(policy): policy[index] = [float(j) for j in policy[index]] #print(policy) P = PI.TransitionProbs(States, Actions, args.Demand_Max, args.LT_s, args.LT_f, args.h, args.b, args.C_s, args.C_f, args.Inv_Max, args.Inv_Min, args.cap_fast, args.cap_slow, dict_states) print('Cost: ', MarkovChain.TestPolicy(States, P, policy))
def cost_per_period(States, Actions, dict_states, args, k, u, m, distribution, identifier, demand_values): start = time.time() P = TransitionProbs(States, Actions, args.Demand_Max, args.LT_s, args.LT_f, args.h, args.b, args.C_s, args.C_f, args.Inv_Max, args.Inv_Min, args.cap_fast, args.cap_slow, dict_states, k, u, m, distribution, demand_values) env = VI.VI_env(States, Actions, P) print('environment created', time.time() - start) #policy, v = PI.policy_improvement(env, args.discount_factor) policy, v = VI.value_iteration(env, theta=0.000001, discount_factor=args.discount_factor) np.save('v_%s_%s_%s.npy' % (identifier, args.LT_s, k), v) optimal_policy = [] MC, MC_R = MarkovChain.MC(States, P, policy) steady_state = MarkovChain.steady_state(States, policy, MC) optimal_cost_array, share_expedited = MarkovChain.cost_steady_state( steady_state, Actions, policy, MC, MC_R) optimal_cost = np.sum(optimal_cost_array) with open( 'optimal_policy-l_e%i-l_r%i-k%i-Distribution %s.csv' % (args.LT_f, args.LT_s, k, identifier), 'w') as f: f.write('OPTIMAL COST;' + str(optimal_cost) + '\n') f.write('Share expedited;' + str(share_expedited) + '\n') f.write('Share regular;' + str(1 - share_expedited) + '\n\n') f.write('PARAMETERS USED:\n') f.write('Demand;Prob\n') for index, item in enumerate(distribution): f.write(str(demand_values[index]) + ';' + str(item) + '\n') f.write('\n') f.write('l_r;') f.write(str(args.LT_s) + '\n') f.write('h;') f.write(str(args.h) + '\n') f.write('b;') f.write(str(args.b) + '\n') f.write('k;') f.write(str(k) + '\n') f.write('u;') f.write(str(u) + '\n') f.write('m;') f.write(str(m) + '\n') f.write('c_r;') f.write(str(args.C_s) + '\n') f.write('\n') for index, __ in enumerate(States[0]): f.write('State' + ';') f.write('optimal local' + ';' + 'optimal offshore') f.write(';prob state;') f.write('cost state;') f.write('weighted cost state;') f.write('\n') for index, state in enumerate(policy): for index2, action in enumerate(state): if (action == 1): #print(States[index],Actions[index2]) optimal_policy.append([States[index], Actions[index2]]) for item in States[index]: f.write(str(item) + ';') for item in Actions[index2]: f.write(str(item) + ';') #print(steady_state,steady_state[0]) f.write(str(steady_state[index]) + ';') if (steady_state[index] > 0): f.write( str(optimal_cost_array[index] / steady_state[index]) + ';') else: f.write(str(0) + ';') f.write(str(optimal_cost_array[index])) f.write('\n') return optimal_cost, share_expedited
num_nodes = len(G) num_items = len(G) k = 50 item_distributions = ['uniform', 'direct', 'inverse', 'ego'] for item_distribution in item_distributions: if item_distribution == 'ego': iterations = 10 else: iterations = 1 for iteration in xrange(iterations): print "Evaluating item distribution {}".format(item_distribution) __builtin__.mc = MarkovChain(num_nodes=num_nodes, num_items=num_items, item_distribution=item_distribution, G=G) print "Starting evaluation of methods" methods = [ random_nodes, highest_item_nodes, highest_closeness_centrality_nodes, highest_in_degree_centrality_nodes, highest_in_probability_nodes, highest_betweenness_centrality_nodes, smart_greedy_parallel ] for method in methods: print "Evaluating method {}".format(method.func_name) get_objective_evolution(method, k, iteration)
def setUp(self): self._c = MarkovChain.MarkovChain()
import MarkovChain import random if __name__ == "__main__": #Make a chain from shakespeare texts chain = MarkovChain.make_shakespear_chain(lines=2000) print "Hello my name is MarkovBot" #Print a ready symbol while (True): input = raw_input(">") #If input is exit, exit if input == "exit": import sys sys.exit() #Search the input for keywords candidate_tuples = [] keywords = input.strip().split() for word in keywords: for tuple in chain.node_dict.keys(): if word in tuple: candidate_tuples.append(tuple) break #Make a response from the keywords in the markov chain response = [] response_candidate_list = [] for tuple in candidate_tuples: response_candidate_list.append(chain.node_dict[tuple]) #Choose a first word words_to_choose = [] for candidate in response_candidate_list: for word in candidate.next_words.keys():
#! /c/Anaconda/python from MarkovChain import * mc = MarkovChain("./markov") # To generate the markov chain's language model, in case it's not present mc.generateDatabase("ThisThis string of Text. is This is a string of Text. a string of Text.It won't is a string of Text. This is a string of Text. It won't generate string of Text. an interesting string of Text.database though.") # To let the markov chain generate some text, execute print mc.generateString()
def characterChain(self, character): tempChain = MarkovChain(2) #Change line order here characterLines = getAllCharLines(self.episodes, character) for line in characterLines: tempChain.addData(line.getChainableSource()) self.chains[character] = tempChain
import MarkovChain import random if __name__ == "__main__": #Make a chain from shakespeare texts chain = MarkovChain.make_shakespear_chain(lines = 2000) print "Hello my name is MarkovBot" #Print a ready symbol while(True): input = raw_input(">") #If input is exit, exit if input == "exit": import sys sys.exit() #Search the input for keywords candidate_tuples = [] keywords = input.strip().split() for word in keywords: for tuple in chain.node_dict.keys(): if word in tuple: candidate_tuples.append(tuple) break; #Make a response from the keywords in the markov chain response = [] response_candidate_list = [] for tuple in candidate_tuples: response_candidate_list.append(chain.node_dict[tuple]) #Choose a first word words_to_choose = [] for candidate in response_candidate_list: for word in candidate.next_words.keys():