def __init__(self, maze):
self.maze = maze
self.inventory = {}
inv_items = ReadFile.get_inventory_types()
for i in range(len(inv_items)):
inv_type = inv_items[i]
self.inventory[inv_type] = ReadFile.get_init_inv_vals()[i]
def AddCorpus(sentences, name):
old_sentences = ReadFile.readTXTFile(config.RegularsFilePath + name +
'.query.txt')
old_R_sentences = ReadFile.readTXTFile(config.RegularsFilePath + name +
".response.txt")
count = len(old_sentences) + 1
for sentence in sentences:
contain = False
Id = name
for o_sen in old_sentences:
lines = o_sen.split('\t')
if lines[1][:-1] == sentence[0]:
contain = True
Id = lines[0]
break
if not contain:
Id += '%05d' % count
count += 1
old_sentences.append(Id + '\t' + sentence[0] + '\n')
for response in sentence[1:4]:
if response != '' or response != '\n' or response != '\t' or len(
response) > 2:
old_R_sentences.append(Id + '\t' + response + '\n')
# write to file
with open(config.ResultFilePath + name + ".query.txt", 'w') as fp:
for line in old_sentences:
fp.write(line)
with open(config.ResultFilePath + name + ".response.txt", 'w') as fp:
for line in old_R_sentences:
fp.write(line)
def AddCorpus(sentences,name):
old_sentences = ReadFile.readTXTFile(config.RegularsFilePath+name+'.query.txt')
old_R_sentences = ReadFile.readTXTFile(config.RegularsFilePath+name+".response.txt")
count = len(old_sentences)+1
for sentence in sentences:
contain = False
Id = name
for o_sen in old_sentences:
lines = o_sen.split('\t')
if lines[1][:-1] == sentence[0]:
contain = True
Id = lines[0]
break
if not contain:
Id += '%05d'%count
count += 1
old_sentences.append(Id+'\t'+sentence[0]+'\n')
for response in sentence[1:4]:
if response != '' or response != '\n' or response != '\t' or len(response) > 2:
old_R_sentences.append(Id+'\t'+response+'\n')
# write to file
with open(config.ResultFilePath+name+".query.txt",'w') as fp:
for line in old_sentences:
fp.write(line)
with open(config.ResultFilePath+name+".response.txt",'w') as fp:
for line in old_R_sentences:
fp.write(line)
def onStartTimeStep(self, interactions_filename, events_filename,
current_time_step):
self.current_time_step = current_time_step
for agent in self.agents_obj.agents.values():
agent.new_time_step()
for location in self.locations_obj.locations.values():
location.new_time_step()
#Add Interactions to agents
if interactions_filename != None:
ReadFile.ReadInteractions(interactions_filename, self.config_obj,
self.agents_obj)
#Add events to locations
if events_filename != None:
ReadFile.ReadEvents(events_filename, self.config_obj,
self.locations_obj)
#Enact policies by updating agent and location states.
for policy in self.policy_list:
policy.enact_policy(self.current_time_step,
self.agents_obj.agents.values(),
self.locations_obj.locations.values(),
self.model)
if events_filename != None:
#Update event info to agents from location
for location in self.locations_obj.locations.values():
if not location.lock_down_state:
for event_info in location.events:
self.model.update_event_infection(
event_info, location, self.agents_obj,
self.current_time_step, self.event_restriction_fn)
def get_file_names_list(example_path, interactions_FilesList_filename,
events_FilesList_filename, config_obj):
# Reading through a file (for interactions/events) that contain file names which contain interactions and event details for a time step
interactions_files_list = None
events_files_list = None
if config_obj.interactions_files_list == '':
print('No Interaction files uploaded!')
else:
interactionFiles_obj = ReadFile.ReadFilesList(
interactions_FilesList_filename)
interactions_files_list = list(
map(lambda x: osp.join(example_path, x),
interactionFiles_obj.file_list))
if interactions_files_list == []:
print('No Interactions inputted')
if config_obj.events_files_list == '':
print('No Event files uploaded!')
else:
eventFiles_obj = ReadFile.ReadFilesList(events_FilesList_filename)
events_files_list = list(
map(lambda x: osp.join(example_path, x), eventFiles_obj.file_list))
if events_files_list == []:
print('No Events inputted')
return interactions_files_list, events_files_list
def Remove(self, key):
locate_file = ReadFile()
record = locate_file.readFile("data.txt")
for year in self.hashTable:
for each in year:
if each[-2:] == key:
year.remove(each)
year.append('-1')
def Remove(self, key):
locate_file = ReadFile()
record = locate_file.readFile("data.txt")
for year in self.hashTable:
for each in year:
if each[-2:] == key:
year.remove(each)
year.append('-1')
def decrement(self): decrement_vals = ReadFile.read_decrement() #Read in how much to decrement by inv_types = ReadFile.get_inventory_types() decrement_amounts = [0]*len(inv_types) for x in range(len(decrement_vals)): if (self.maze.total_step_count ) % decrement_vals[x][0] == 0: #Should dec? self.inventory[inv_types[x]] -= decrement_vals[x][1] decrement_amounts[x] = decrement_vals[x][1] return decrement_amounts
def main():
import os
import sys
A, b, c = ReadFile.read("../data/A.txt", "../data/b.txt", "../data/c.txt")
x = np.zeros(len(c))
x[0] = 0.1
x[1] = 0.2
H = Hessian(A, b, x)
ReadFile.printMatrix(H)
return 0
def create_data(data_in, data_flag, number):
path = "C:/Users/Nao KeTeng/OneDrive/桌面/input.log"
data = []
ReadFile.readfile(path, data)
for _ in data: # 舍弃第一个数据
_.pop(0)
time = 3
flag = 0
polynomial = [0, 0, 0, 0]
# aa:训练拟合权重
aa = 0.8
for temp in data:
z1 = np.polyfit(list(range(len(temp), 0, -1)), temp, time)
p1 = np.poly1d(z1)
if (polynomial[0] + polynomial[1] + polynomial[2] + polynomial[3]) == 0:
flag = 1
else:
flag = 0
if flag != 1:
for i in range(time + 1):
polynomial[i] = (1 - aa) * p1[i] + aa * polynomial[i]
else:
for i in range(time + 1):
polynomial[i] = p1[i] + polynomial[i]
result = []
for i in range(15, 0, -1):
result_temp = polynomial[0]+(polynomial[1]*i)+(polynomial[2]*(i**2))+(polynomial[3]*(i**3))
result.append(result_temp)
if data_flag == 2:
for i in range(number):
start = random.randint(1, 10)
translation = np.random.normal(0, 4)
jj = 0
data_temp = []
for _ in result:
_ += (math.cos(math.pi * (start+jj)) * abs(np.random.normal(0, 4))) + translation
jj += 1
data_temp.append(_)
data_in.append(copy.deepcopy(data_temp))
data_temp.clear()
elif data_flag == 3:
for i in range(int(number/len(data))):
for one in data:
data_temp = []
for _ in one:
data_temp.append(_ + +np.random.normal(-5, 5))
data_in.append(copy.deepcopy(data_temp))
data_temp.clear()
def Main(cp, ip, to_stem):
global __corpus_path
global __index_path
global doc
global __stem_suffix
create_city_db()
Parser.stem = to_stem
if to_stem is True:
__stem_suffix = '_stem'
else:
__stem_suffix = ''
start = time.time()
data_set_Path(cp, ip)
Indexer.create_posting_files(__stem_suffix)
counter = 0
for root, dirs, files in os.walk(__corpus_path):
for file in files:
if (stop==True):
reset() #will clear the memory of the program %% will remove the posting files and dictionary
return
#print("file!!!")
end2 = time.time()
# if ((end2-start)/60)>10 and ((end2-start)/60) <10.10:
# print(str(file))
if str(file) != 'stop_words.txt':
ReadFile.takeDocsInfoFromOneFile(str(pathlib.PurePath(root, file)))
dic_of_one_file = Parser.parse(dic_to_parse)
sorted_dictionary = collections.OrderedDict(sorted(dic_of_one_file.items()))
index_start = time.time()
Indexer.merge_dictionaries(sorted_dictionary)
dic_to_parse.clear()
counter += 1
if counter == 100:
Indexer.SaveAndMergePostings()
counter = 0
Indexer.SaveAndMergePostings()
saveCityDictionaryToDisk(ip)
saveMainDictionaryToDisk(ip)
cleanDocsYeshuyot()
saveDocumentDictionaryToDisk(ip)
x= ReadFile.docs_dictionary
saveLangListToDisk(ip)
saveStopWordsDictToDisk(ip)
#ranker things
createAndSaveAvdlToDisk(ip)
x=ReadFile.lang_list
end2 = time.time()
time_final = str((end2 - start) / 60)
print("time of program: " + time_final)
sendInfoToGUI(time_final)
def give_prize(self, inv_type, amount): num = -1 for x in range(len(ReadFile.get_inventory_types())): #Get the inv num if ReadFile.get_inventory_types()[x] == inv_type: num = x break cap = ReadFile.read_caps()[num] if cap == None: #Unbounded cap self.inventory[inv_type] += amount else: #Bounded cap difference = cap - self.inventory[inv_type] #How much left can be added self.inventory[inv_type] += min(difference, amount)
def is_dead(self): inv_types = ReadFile.get_inventory_types() mins = ReadFile.get_mins() #Smallest possible amount dead_at = [False, False, False] #At each inventory item, are you ok? for x in range(len(self.inventory)): if self.inventory[inv_types[x]] < mins[x]: dead_at[x] = True self.inventory[inv_types[x]] = mins[x] return dead_at
def reset(param=None):
global __corpus_path,__index_path, __stem_suffix
if param == "Queries":
Parser.reset()
__corpus_path = ""
else:
ReadFile.reset()
Parser.reset()
Indexer.reset()
remove_index_files()
__stem_suffix = ''
__corpus_path = ""
__index_path = ""
def log_in(self, u_log, u_pass):
global login
global user_path
if u_log.get() in rf.check_login():
if u_pass.get() == rf.check_pass(u_log.get()):
print('Logged in')
login = u_log.get()
self.change_frame(MainMenu)
else:
print('wrong password')
else:
print('user not exist')
def mP(a, tab, Aligner, sc):
manager = multiprocessing.Manager()
alignments = manager.list()
cores = int(input('Inserisci il numero di processori: '))
if cores > multiprocessing.cpu_count():
cores = multiprocessing.cpu_count()
print("Superato il numero massimo di processori,", str(cores),
"in uso")
else:
print(str(cores), "processori in uso")
processes = []
data = ReadFile.SPARKreadFile(sc)
dict = [x["SEQ"] for x in data.rdd.collect()]
#dict = ReadFile.HengLireadFile() #Heng Li
chunk_size = len(dict) / cores
slices = Chunks(dict, math.ceil(chunk_size))
for i, s in enumerate(slices):
procname = 'processor' + str(i)
p = multiprocessing.Process(target=Alignment.mPalignment,
args=(a, tab, Aligner, s, alignments,
procname))
p.start()
processes.append(p)
for p in processes:
p.join()
DF = spark.createDataFrame(alignments)
DataFrame = DF.join(data, on=['seq'], how='inner')
return DataFrame
def draw_inv_text(self): #Box around the text here
PERCENT_UP = 0.95 #How far up is the text?
FONT = GLUT_BITMAP_9_BY_15
LOADING_WIDTH = 40
LOADING_HEIGHT = 10
TEXT_LOADINGBAR_GAP = 10
text_top = PERCENT_UP * SCREEN_SIZE[1] #Text starts from here
GLComponents.glEnable2D()
max_length = 0
for item_num in range(len(self.inventory.inventory)): #Longest sentence
key = self.inventory.inventory.keys()[item_num]
cap = ReadFile.read_caps()[item_num]
if cap:
message = "{0}: {1:.2f}%".format(key, self.inventory.inventory[key]/cap * 100.0)
else:
message = "{0}: {1:.2f}".format(key, self.inventory.inventory[key])
width = self.str_width(message, FONT)
if width > max_length:
max_length = width
GLComponents.write_str(message, 0, text_top - item_num * 15, FONT)
if cap: #Only capped values get loading bars
GLComponents.loading_bar(max_length + TEXT_LOADINGBAR_GAP, text_top - 15 * item_num,
self.inventory.inventory[key]/cap * 100, LOADING_WIDTH, LOADING_HEIGHT)
GLComponents.draw_rect(0, max_length + LOADING_WIDTH + TEXT_LOADINGBAR_GAP + 2,
text_top + 15, text_top - len(self.inventory.inventory) * 15)
GLComponents.glDisable2D()
def generate_bulk_insert_data(self, file_folder, num):
read_file = ReadFile.ReadFile(file_folder)
# return list data -> generate bulk data
# list data contains json like data
# add action and meta data to every json data
# 进行数据冗余
# 从url指定位置，减少每次action动作的数据
action = {"index": {}}
bulk_data = ""
for data_list in read_file.get_data(num):
# data list -> data
# 传过来的data为从源文件取出的json格式
# 对content做数据冗余，先将json载入为map，再添加，然后再dumps为json格式
for data in data_list:
try:
data_map = json.loads(data, encoding='utf-8')
data_map['title1'] = data_map['title']
data_map['tag'] = {"input": data_map['title']}
data_map['text1'] = data_map['text']
data_map['time'] = data_map['time']
data_map['timestamp'] = time.mktime(
time.strptime(data_map['time'], '%Y-%m-%d %H:%M:%S'))
#print(data_map['timestamp'])
bulk_data += json.dumps(
action, ensure_ascii=False) + '\n' + json.dumps(
data_map, ensure_ascii=False) + '\n'
except:
continue
bulk_data += '\n'
yield (bulk_data)
bulk_data = ""
def inputfilecontaindict2list(filename):
inputfilelines = ReadFile.ReadExpectFile(filename)
inputlist = []
for inputfileline in inputfilelines:
inputfileline = inputfileline.replace('\n', '')
inputfileline = inputfileline.replace('\"', '')
inputfileline = inputfileline.replace(': ', '=')
inputfileline = inputfileline.replace(' ', '')
inputfileline = inputfileline.replace('={', '=@')
inputfileline = inputfileline.replace('},', '**,')
inputfileline = inputfileline.replace('{', '')
inputfileline = inputfileline.replace('}', '')
inputfileline = inputfileline.replace('[0,0,1,0,0,0,0,0]', '###')
# print inputfileline
inputtemplist = inputfileline.split(",")
inputdict = {}
for i in range(len(inputtemplist)):
if inputtemplist[i].find('=@') != -1:
inputtemplist[i] = inputtemplist[i].split("=@")[1]
if inputtemplist[i].find('**') != -1:
inputtemplist[i] = inputtemplist[i].split('**')[0]
if inputtemplist[i].find('###') != -1:
inputtemplist[i] = inputtemplist[i].replace(
"###", '[0,0,1,0,0,0,0,0]')
inputtemplist2 = inputtemplist[i].split('=')
inputdict[inputtemplist2[0]] = inputtemplist2[1]
inputlist.append(inputdict)
return inputlist
def HLalignment(a, alignments, tab, Aligner,sc):
dict = ReadFile.readFile3()
# counter = 0
for name, seq, qual in dict.values():
try:
hit = next(a.map(seq, MD=True, cs=True))
# dict = {}
flag = 0 if hit.strand == 1 else 16
seq = seq if hit.strand == 1 else seq.translate(tab)[::-1]
clip = ['' if x == 0 else '{}S'.format(x) for x in (hit.q_st, len(seq) - hit.q_en)]
if hit.strand == -1:
clip = clip[::-1]
cigar = "".join((clip[0], hit.cigar_str, clip[1]))
alignment = Aligner(contig=hit.ctg, Rname=name, flag=flag, pos=hit.r_st, mapq=hit.mapq, cigar=cigar, seq=seq, is_primary=hit.is_primary, MDtag=hit.MD, cstag=hit.cs, basequal=qual)
# dict['counter','Qname', 'flag', 'Rname', 'pos', 'mapq', 'cigar', 'seq', 'is_primary'] = name, flag, hit.ctg, hit.r_st, hit.mapq, hit.cigar_str, seq, hit.is_primary
if hit.mapq >= 10:
# alignments.append(dict['counter','Qname', 'flag', 'Rname', 'pos', 'mapq', 'cigar','seq', 'is_primary'])
alignments.append(alignment)
# counter += 1
except StopIteration:
alignment = Aligner(contig='chr0', Rname=name, flag=4, pos=None, mapq=None, cigar=None, seq=seq, is_primary=False, MDtag=None, cstag=None, basequal=qual)
alignments.append(alignment)
rdd = sc.parallelize(alignments)
seqDF = rdd.map(lambda x: Row(contig=x[0], Rname=x[1], flag=x[2], pos=x[3], mapq=x[4], cigar=x[5], seq=x[6], is_primary=x[7], MDtag=x[8], cstag=x[9], basequal=x[10]))
DF = sqlContext.createDataFrame(seqDF)
return DF
def __init__(self, room_type = None, colours = None, is_choice_room = False,
possible_prize = None, prize = None, depth = 0, options = None,
last_pos = None):
self.adjacent = {}
self.room_type = room_type
self.is_choice_room = is_choice_room
if prize == None:
self.prize = [None, 0, False]
else:
self.prize = prize
self.depth = depth
self.options = options
if colours == None:
self.colours = self.generate_colours(self.room_type)
else:
self.colours = colours
self.last_pos = last_pos
self.prize_infos = [ReadFile.get_option() for x in range(3)] #This contains three instances of ReadFile.get_option().
self.prize_infos[1] = None #overwrite middle one so now cue in centre
#This is just a detailed version of prize_order. In fact, prize order only exists
#since it was made before prize_info was needed, and it is now hard to remove.
self.prize_order = [None, None, None]
def main():
root = utils.get_root_path(False)
usage = "usage: %prog [options] arg"
parser = OptionParser(usage)
parser.add_option('--learning_rate_rbm',
action='store',
type='string',
dest='learning_rate_rbm')
parser.add_option('--epochs_rbm',
action='store',
type='string',
dest='epochs_rbm')
parser.add_option('--batch_size',
action='store',
type='string',
dest='batch_size')
parser.add_option('--data_set',
action='store',
type='string',
dest='data_set')
(opts, args) = parser.parse_args()
file_data = ReadFile.ReadFile(root + '/NSL_KDD-master',
opts=opts).get_data()
data_pp = preprocess.Preprocess(file_data).do_predict_preprocess()
dbn_model.DBN(data_pp).do_dbn('yadlt', opts=opts)
dbn_model.DBN(data_pp).do_dbn_with_weight_matrix(root + '/save')
model.do_svm()
def filterStopWords(Words):
New_words = []
stopWords = ReadFile.readStopWord(MyCode.config.StopWordPath + 'stop_2.txt')
for word in Words:
if word not in stopWords:
New_words.append(word)
return New_words
def __init__(self, maze): self.time = pygame.time.get_ticks() self.maze = maze self.possible_times = ReadFile.read_times() self.next_straight_time = self.get_wait_time() self.num_chars = 0 #Number of times MRI outputs
def print_path(self):
self.filename = filedialog.askopenfilename(initialdir="/", title="Select file",
filetypes=(("text file", ".txt"), ("all files", ".*")))
self.configure(background="white")
global file
file=1
ReadFile.ReadFromFile(self.filename)
def _get_majors(self, path):
""" Read majors files and assign the course to the majors
Handle exceptions in the calling function.
"""
for major, flag, course in rf.file_reading_gen(path, 3, sep='\t', header=True):
if major not in self._majors:
self._majors[major] = Major(major)
self._majors[major].add_course(course, flag)
def partical_block(file_path, start_num_list_modify, end_num_list_modify):
basic_text_only_if = list()
for i in range(0, len(start_num_list_modify)):
basic_text_only_if.append(
ReadFile.read_need_partical_File(file_path,
start_num_list_modify[i] - 1,
end_num_list_modify[i]))
return basic_text_only_if
def translatefile(filename):
inputfile = filename
iReadStart = getReadStart(filename)
iFileIndex = getFileIndex(filename)
readObj = ReadFile(inputfile)
iFileSize = readObj.filesize()
(iPos, data) = readObj.readvalue(iReadStart, 12)
while(len(data) > 0):
oldFile = getoldfile()
if iReadStart == 0:
newName = convert2filename(iFileSize, 0, filename)
else:
newName = convert2filename(iPos, iFileIndex, data)
while (len(oldFile) == 0):
sleep(1000)
oldFile = getoldfile()
convert2newfile(oldFile, newName)
def train():
fileName = "trainData.model"
test = ReadFile.QAData("training.data")
test.readFile()
ProD.wordSeg(test)
ProD.delHighFre_useless(test)
ProD.delHighFre_psg(test)
trainModel(test, fileName)
def Allen(fileUsesMathSigns=True):
if fileUsesMathSigns:
file1 = "algebra/allen2.txt"
file2 = "algebra/ia_ord_horn_C2.txt"
else:
file1 = "algebra/allen.txt"
file2 = "algebra/ia_ord_horn_C.txt"
algFile = ReadFile.AlgebraFile(file1)
horn = ReadFile.ATractableSubsetsFile(file2)
alg = Algebra(algFile, horn)
alg.equality = ("=" if fileUsesMathSigns else "EQ")
# print(alg)
alg.checkIntegrity()
print("Reading compositions file ...")
print("\n")
alg.readCompositionsFile("algebra/allen.compositions")
return alg
def _get_students(self, path):
''' Read students from path and add to the self.students
Allow exceptions from reading the file to flow back to the caller.
'''
for cwid, name, major in rf.file_reading_gen(path, 3, sep=';', header=True):
if major not in self._majors:
print(f"Student {cwid} '{name}' has unknown major '{major}'")
else:
self._students[cwid] = Student(cwid, name, self._majors[major])
def getKeyWordsAndResponses(file):
dataFilePath = config.InputDataFilePath
resultFile = config.InputDataFilePath
bk,table_names = ReadFile.readCorpusExcel(dataFilePath+'badcase/'+file+'.xlsx')
for name in table_names:
table = bk.sheet_by_name(name)
sentences = getTableContext(table)
AddCorpus(sentences,name)
def ODPSoutputfile2list(filename):
outputfilelines = ReadFile.ReadRealFlie(filename)
outputlist = []
for outputfileline in outputfilelines:
outputfileline = outputfileline.replace('\n', '')
outputfilelinelist = outputfileline.split(",")
outputlist.append(outputfilelinelist)
return outputlist
def getKeyWordsAndResponses(file):
dataFilePath = config.InputDataFilePath
resultFile = config.InputDataFilePath
bk, table_names = ReadFile.readCorpusExcel(dataFilePath + 'badcase/' +
file + '.xlsx')
for name in table_names:
table = bk.sheet_by_name(name)
sentences = getTableContext(table)
AddCorpus(sentences, name)
def filterStopWordFromSentences(sentences):
stopWords = ReadFile.readStopWord(MyCode.config.StopWordPath + 'stop_2.txt')
filter_sentences = []
for sentence in sentences:
filter_sentence = []
for w in sentence:
if w not in stopWords:
filter_sentence.append(w)
filter_sentences.append(filter_sentence)
return filter_sentences
def run_simulation(test_cost, fp_cost, quarantine_cost, infection_cost, n, p,
beta, gamma, napt, ntpa, testing_gap, tests_per_period,
turnaround_time, restriction_time, fn, fp):
testing_gap += 1
config_filename = get_config_path('')
# Read Config file using ReadFile.ReadConfiguration
config_obj = ReadFile.ReadConfiguration(config_filename)
agents_filename = 'agents.txt'
interactions_files_list = ['interactions_list.txt']
locations_filename = None
events_files_list = []
# User Model
model = get_model(beta, gamma)
##########################################################################################
policy_list = []
# Group/Pool Testing
def testing_fn(timestep):
if timestep % testing_gap == 0:
return tests_per_period * napt / ntpa
return 0
Pool_Testing = Testing_Policy.Test_Policy(testing_fn)
Pool_Testing.add_machine('Simple_Machine', test_cost, fp, fn,
turnaround_time, 1000, 1)
Pool_Testing.set_register_agent_testtube_func(
Pool_Testing.random_agents(napt, ntpa))
policy_list.append(Pool_Testing)
ATP = Lockdown_Policy.agent_policy_based_lockdown("Testing", ["Positive"],
lambda x: True,
restriction_time)
policy_list.append(ATP)
def event_restriction_fn(agent, event_info, current_time_step):
return False
###############################################################################################
world_obj = World.World(config_obj, model, policy_list,
event_restriction_fn, agents_filename,
interactions_files_list, locations_filename,
events_files_list)
# world_obj.simulate_worlds(plot=True)
tdict, total_infection, total_quarantined_days, wrongly_quarantined_days, total_test_cost = world_obj.simulate_worlds(
plot=False)
cost = total_infection * infection_cost + total_quarantined_days * quarantine_cost + total_test_cost + world_obj.total_false_positives * fp_cost
return cost
def main():
import os
import sys
A, b, c = ReadFile.read("../data/A.txt", "../data/b.txt", "../data/c.txt")
x = np.zeros(len(c))
x[0] = 0.1
x[1] = 0.2
t = 1.0
print "Gradient = ", gradient(t, A, b, c, x)
return 0
def runScript(findsomething):
command = 'show system info\n'
inputValue = text_entry.get("1.0", "end-1c")
arrayValue = ReadFile.openFile("file.txt")
inputArray = inputValue.splitlines()
for x in inputArray:
print x
sshOutput = SSH.connectToDevice(x, command)
valueFound = Find.findString(findsomething, sshOutput)
WriteOutput.appendOutput(valueFound, x, 'output.txt')
print "Output written to output.txt"
def pruningAlgorithm(decisionTree, K, validation_filename):
bestDecisionTree = copy.deepcopy(decisionTree)
testFile = ReadFile.readfile(validation_filename)
maxAccuracyWithID3 = accuracyFind(decisionTree, testFile.trainingValues)
print("Accuracy with ID3 DT against Test set: ")
print(str(maxAccuracyWithID3))
pruneDecisionTree = copy.deepcopy(decisionTree)
arrayOfNodes = []
collectAllNodes(pruneDecisionTree, arrayOfNodes)
j = 0
while j < K:
N = len(arrayOfNodes)
P = random.randint(0, N - 1)
pCnt = 0
nCnt = 0
arrayOfNodes[P].left = BinaryTreeFormat.BinTree()
arrayOfNodes[P].right = BinaryTreeFormat.BinTree()
arrayOfNodes[P].left.testAttrForCurrentNode = "class"
arrayOfNodes[P].right.testAttrForCurrentNode = "class"
for eachSet in arrayOfNodes[P].dataForPruning:
if eachSet != "tested":
if arrayOfNodes[P].dataForPruning[eachSet]["class"] == "1":
pCnt += 1
else:
nCnt += 1
if pCnt > nCnt:
arrayOfNodes[P].left.label = "+"
arrayOfNodes[P].right.label = "+"
else:
arrayOfNodes[P].left.label = "-"
arrayOfNodes[P].right.label = "-"
j += 1
currentTreeAccuracy = accuracyFind(pruneDecisionTree,
testFile.trainingValues)
print("Accuracy after Pruning against Test set: ")
print(currentTreeAccuracy)
print("Number of nodes in a pruned tree:")
print(DT_size(pruneDecisionTree, count=0))
print("Number of Leaf nodes in a pruned tree:")
print(DT_leaf_nodes(pruneDecisionTree))
'''print("Average depth: ")
average = float(totalDepth(pruneDecisionTree,level=0)) / float(DT_leaf_nodes(pruneDecisionTree))
print(average)'''
if maxAccuracyWithID3 < currentTreeAccuracy:
maxAccuracyWithID3 = currentTreeAccuracy
print("Overfitting deducted: Tree interchanged")
bestDecisionTree = copy.deepcopy(pruneDecisionTree)
return bestDecisionTree
def generate_prize_order(self): possible_prizes = ReadFile.get_inventory_types() possible_prizes.append(None) ordered = [] for x in range(3): random_number = randint(0, len(possible_prizes) - 1) ordered.append(possible_prizes[random_number]) if possible_prizes[random_number] == None: possible_prizes.remove(None) #Prevent more than 1 None return ordered
def main():
start = time.time()
input_filename = sys.argv[1]
output_filename_id_zip = sys.argv[2]
output_filename_id_date = sys.argv[3]
io = rf.InputOutput(input_filename, output_filename_id_zip,
output_filename_id_date, '|')
io.read_process_write()
end = time.time()
print('V1 (no pandas) processing time: ' + str(round(end - start, 3)) +
' (seconds)')
def filterStopWordsInSentences(par_sentences):
# file = "../../Data/StopWords/stop.txt"
stopWords = ReadFile.readStopWord(MyCode.config.StopWordPath + 'stop_2.txt')
filter_Par_Sentences = []
for par_sentence in par_sentences:
filterSentences = []
for sen in par_sentence:
words = []
for word in sen:
if word not in stopWords:
words.append(word)
filterSentences.append(words)
filter_Par_Sentences.append(filterSentences)
return filter_Par_Sentences
def filterStopWords(sentences,file=MyCode.config.StopWordPath+'stop_2.txt'):
stopWords = ReadFile.readStopWord(file)
filterSentences = []
noFilterSentences = []
for sentence in sentences:
filter_words = []
nofilterWords = []
for sen in sentence:
nofilterWords.append(sen)
if sen not in stopWords:
filter_words.append(sen)
filterSentences.append(filter_words)
noFilterSentences.append(nofilterWords)
return filterSentences,noFilterSentences
def Get(self, query):
locate_file = ReadFile()
record = locate_file.readFile("data.txt")
if '|' in query:
info = query.split('|')
year_index = int(info[0]) % 10
movie_type = self.type.index(info[1])
index = str(info[0]) + '0' + str(movie_type)
for each in self.hashTable[year_index]:
if each[:6] == index:
location = int(each[6:])
print ", ".join(record[location])
elif each == '-1':
return "The record is not in the database"
else:
year_index = int(query) % 10
for each in self.hashTable[year_index]:
if each == '-1':
# print "no more record in query"
break
else:
if each[:4] == query:
location = int(each[6:])
print ", ".join(record[location])
def add_output_buffer_postlim(self):
position = self.maze.position.last_pos
if position != None: #Choice
if position.is_choice_room:
self.out_list.append(str(self.maze.position.prize[0]))
else:
self.out_list.append("-1")
inv_types = ReadFile.get_inventory_types()
self.out_list.extend([str(self.inventory.inventory[inv_types[x]]) for x in range(3)])
if self.maze.position.prize[2]: #If just got a prize
self.out_list.extend([str(self.maze.position.prize[0]), str(self.maze.position.prize[1])])
else:
self.out_list.extend(['None', 'None'])
def makeBags():
BagStrings = ReadFile.readFile()
i = 0
j = 0
for a in BagStrings:
for a2 in a:
BagStrings[i][j] = BagStrings[i][j] + " "
j+= 1
i += 1
j = 0
BagDog = categoryDictionary(BagStrings[0])
print("test")
BagTweens = categoryDictionary(BagStrings[1])
print("test")
BagResearch = categoryDictionary(BagStrings[2])
print("test")
return [BagDog, BagTweens, BagResearch]
def step(self, direction, hall_type = Hallways.TRIFURC): if direction not in self.position.adjacent: #Not visited new_pos = MazeComponent(hall_type) new_pos.last_pos = self.position if self.position.is_choice_room: #In a choice room new_pos.is_choice_room = False self.assign_possible_prize(new_pos, direction) new_pos.depth = 1 new_pos.options = ReadFile.get_option(new_pos.prize[0]) self.set_has_prize(new_pos) #Winner? else: #In a `straight' choiceless room if direction in [Directions.LEFT, Directions.RIGHT]: #the user turns new_pos.is_choice_room = True #Determine order o' prizes new_pos.set_prize_order(self.generate_prize_order()) elif direction == Directions.FORWARDS: #User proceeds forward #default of is_choice_room is false new_pos.prize[0] = self.position.prize[0] new_pos.depth = self.position.depth + 1 new_pos.options = self.position.options self.set_has_prize(new_pos) #Winner? self.position.adjacent[direction] = new_pos #Allow yourself to go backwards if direction == Directions.FORWARDS: new_pos.adjacent[Directions.BACKWARDS] = self.position elif direction == Directions.BACKWARDS: new_pos.adjacent[Directions.FORWARDS] = self.position elif direction == Directions.LEFT: new_pos.adjacent[Directions.BACKWARDS] = self.position elif direction == Directions.RIGHT: new_pos.adjacent[Directions.BACKWARDS] = self.position self.position = new_pos elif self.position.adjacent[direction] != None: self.position.adjacent[direction].last_pos = self.position self.position = self.position.adjacent[direction] self.position.prize = [self.position.prize[0], 0, False]
def add_output_buffer_postlim(self, direction, current_inventory, decrement_amounts):
position = self.maze.position.last_pos
# if position != None: #Choice
# if position.is_choice_room:
# self.out_list.append(str(self.maze.position.prize[0]))
# else:
# self.out_list.append("-1")
global chosen_direction, chasing_infos, str_infos
chosen_direction = direction # for updating centre/chasing infos later
self.out_list.append(direction) # Direction chosen
# to update chasing info for next turn (ie what you just selected) and output the infos of the current chosen direction to file
if direction == "left":
chasing_infos = self.prize_info_to_string(position.prize_infos[0])
self.out_list.extend(str_infos[0:4])
elif direction == "right":
chasing_infos = self.prize_info_to_string(position.prize_infos[2])
self.out_list.extend(str_infos[4:8])
elif direction == "centre" and self.maze.position.prize.count(None) != len(
self.maze.position.prize
): # if centre, don't update, unless prize given, then update to nones
chasing_infos = ["None", "None", "None", "None"]
self.out_list.extend(str_infos[0:4])
inv_types = ReadFile.get_inventory_types()
# for prize and decrease
for x in inv_types:
if x == self.maze.position.prize[0]:
self.out_list.append(str(self.maze.position.prize[1]))
else:
self.out_list.append("0")
self.out_list.extend([str(x) for x in decrement_amounts])
self.out_list.extend([str(current_inventory[inv_types[x]]) for x in range(len(inv_types))]) # Inventory
def add_output_buffer_postlim(self, direction, current_inventory, decrement_amounts):
position = self.maze.position.last_pos
if position != None: #Choice
if position.is_choice_room:
self.out_list.append(str(self.maze.position.prize[0]))
else:
self.out_list.append("-1")
self.out_list.append(direction) #Direction chosen
inv_types = ReadFile.get_inventory_types()
self.out_list.extend([str(current_inventory[inv_types[x]]) for x in range(3)]) #Inventory
for x in inv_types:
if x == self.maze.position.prize[0]:
self.out_list.append(str(self.maze.position.prize[1]))
else:
self.out_list.append('0')
self.out_list.extend([str(x) for x in decrement_amounts])
def __init__(self):
self.inventory = {}
for inv_type in ReadFile.get_inventory_types():
self.inventory[inv_type] = 0
__author__ = 'ajayvembu' import ReadFile import KMeanAlgorithmUpdatedV1 import ValidateKMean import sys numberOfClusters = int(sys.argv[1]) testFileName = str(sys.argv[2]) outPutFileName = str(sys.argv[3]) testData = ReadFile.readFileForKMean(testFileName) KMeanResult = KMeanAlgorithmUpdatedV1.KMeanAlgorithm(testData,numberOfClusters) sSE = ValidateKMean.squaredErrorFunction(KMeanResult.clusters,KMeanResult.centroids) ReadFile.writeToKMeaFile(outPutFileName,KMeanResult) print sSE
__author__ = 'jarfy'
from ReadFile import *
from hashmap import *
test = ReadFile()
data = test.readFile("data.txt")
formate = test.getType()
operator = MovieIndex(formate)
operator.MovieHash(data)
print "show movie index"
print operator.hashTable
print
print "put 46th record into index"
operator.Put(46, "The Abyss,1970,LaserDisc,Science Fiction,James Cameron,James Cameron,USA,20th Century Fox,$0.00")
print operator.hashTable
print
print "Find all movies made in 2000"
operator.Get("2000")
print
print "Find all movies made in 2005"
operator.Get("2005")
print
print "Find all movies made in 2010"
operator.Get("2010")
print
print "Find all DVD movies made in 1977"
operator.Get("1977|DVD")
print
print "Find all VHS movies made in 1990"
operator.Get("1990|VHS")
print
menuList = ["Read file", "Export XML File", "Update User"]
i = 1;
print "Available options:"
for menuEntry in menuList:
print i, menuEntry
i+=1
selectedEntry = 0;
while ((selectedEntry <= 0) or (selectedEntry > len(menuList))):
try:
selectedEntry = int(raw_input("Please select an option from the menu "))
if((selectedEntry <= 0) or (selectedEntry > len(menuList))):
print "Not a valid option"
except(ValueError):
print "That's not a valid entry"
print "You have selected", menuList[selectedEntry - 1]
if (selectedEntry == 1):
readFile.doSomething()
elif (selectedEntry == 3):
updateEntry.doSomething()
elif (selectedEntry == 2):
generator.printXml()
import ReadFile
import os
import sys
if len(sys.argv)<2:
print "Command Args error."
print "Help: python ifc.py <filename> [-o <filetype>]"
exit()
fname=sys.argv[1]
if(len(sys.argv)>2 and sys.argv[2]=='-o'):
ty=sys.argv[3]
else:
ty='png'
res=ReadFile.read(fname.strip(".ifc")+".ifc")
#for key,value in res.items():
#print key,value
dot=file(fname+".dot","w")
dot.write("digraph classic0{\n")
for key,value in res.items():
#print key,value
i=value[1].find('#')
while i>-1:
strleft=value[1][i+1:]
j1=strleft.find(',')
j2=strleft.find(')')
j=min(j1,j2) if (j1>-1 and j2>-1) else max(j1,j2)
dot.write(key+"->"+strleft[:j]+"\n")
#print (key+"->"+strleft[:j]+"\n")
value[1]=strleft[j:]
i=value[1].find('#')
