def my_read(file):
num_days, book_scores, libs = read_file(file)
book_occ = book_occurences(libs, len(book_scores))
mean_book_occ = sum(book_occ)
book_occ = [item / mean_book_occ for item in book_occ]
books = [
Book(i, score, book_occ[i]) for i, score in enumerate(book_scores)
]
# check = [1 for _ in range(len(books))]
libraries = []
for lib in libs:
num_books_in_lib = lib['num_books_in_lib']
sign_up_t = lib['sign_up_t']
ship_per_day = lib['ship_per_day']
book_ids = lib['book_ids']
lib_books = [books[id] for id in book_ids]
# for book_id in book_ids:
# check[book_id] = 0
libraries.append(
Library(num_books_in_lib, sign_up_t, ship_per_day, lib_books))
# some books are found in no library
# checksum = sum(check)
# assert checksum == 0
return libraries, books, num_days
def main(_):
# tf.reset_default_graph()
un = False
max_len = 128
sents, labels = read_file('./data/train')
test_sents, test_labels = read_file('./data/test')
vocab = read_vocab()
data = sent2vec(sents, vocab, max_len)
test_data = sent2vec(test_sents, vocab, max_len)
model = Model(len(vocab), max_len)
#model = Transformer(len(vocab), max_len)
epoch = 100
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
init = tf.global_variables_initializer()
sess.run(init)
model.train(data, labels, test_data, test_labels, sess, epoch)
def main(_):
tf.reset_default_graph()
un = False
max_len = 2048
sents, labels = read_file('./data/train.txt')
test_sents, test_labels = read_file('./data/test.txt')
vocab = read_vocab()
data = sent2vec(sents, vocab, max_len)
test_data = sent2vec(test_sents, vocab, max_len)
if un == True:
un_sents, un_labels = read_file('./data/unsup.txt')
un_data = sent2vec(un_sents, vocab, max_len)
#model = single_filter_Model(len(vocab), max_len)
model = multi_filter_Model(len(vocab), max_len)
epoch = 100
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
init = tf.global_variables_initializer()
sess.run(init)
if un == True:
model.train(un_data, un_labels, test_data, test_labels, sess, 10)
model.train(data, labels, test_data, test_labels, sess, epoch)
def main(id_input):
B = 100
scanned_books = np.zeros(B)
hard_code_path_to_input = "/home/raphael/PycharmProjects/hashcode_2/input/"
tab_input = ["a_example.txt",
"b_read_on.txt",
"c_incunabula.txt",
"d_tough_choices.txt",
"e_so_many_books.txt",
"f_libraries_of_the_world.txt",
]
num_days, book_scores, libs = read_file(hard_code_path_to_input + tab_input[id_input])
days_left = num_days
for id_lib, lib in enumerate(libs):
lib["set_books"] = set(lib["book_ids"])
lib["id"] = id_lib
lib["set_books_with_score"] = set()
lib["taken"]=0
score_in_lib = 0
for book in lib["book_ids"]:
lib["set_books_with_score"].add((book, book_scores[book]))
score_in_lib += book_scores[book]
lib["score_in_lib"] = score_in_lib
global_output = "{}\n".format(number_output_libs) + middle_output
print("output_text", global_output)
result_file = hard_code_path_to_input+"result/result_"+tab_input[id_input]
with open(result_file, 'w') as file:
file.write(global_output)
def main():
statements, interogations, coeficients = read.read_file(sys.argv[1])
for st in statements:
print(st, coeficients[atom_utils.convert_to_tuple(st)])
if coeficients[atom_utils.convert_to_tuple(st)] != 1:
atom_utils.has_coeficients = True
print()
for intr in interogations:
print("Scopul de demonstrat " +
atom_utils.print_formula(intr[1], return_result=True))
statements_aux = copy.deepcopy(statements)
atom_utils.var_sol_list = check_for_vars(intr[1])
atom_utils.has_vars = True if atom_utils.var_sol_list != [] else False
atom_utils.was_proved = False
atom_utils.all_solutions = []
atom_utils.visited = []
atom_utils.initial_theorem = intr[1]
atom_utils.coeficients = coeficients
atom_utils.coeficients_sol_list = []
atom_utils.longest_formula = ""
atom_utils.backward_chaining(statements_aux, intr[1], [], {}, 1)
print("Gata")
if atom_utils.has_vars:
print(
print_all_solutions(atom_utils.all_solutions,
atom_utils.var_sol_list))
else:
if atom_utils.all_solutions == []:
print(
atom_utils.print_formula(intr[1], return_result=True) +
" is false\n")
else:
print(
atom_utils.print_formula(intr[1], return_result=True) +
" is True")
if atom_utils.has_coeficients:
print("Coeficient: " +
"%.3f" % atom_utils.coeficients_sol_list[0])
print()
import read
import numpy as np
import tensorflow as tf
from tensorflow.python.ops import rnn, rnn_cell
import matplotlib.pyplot as plt
import RNN
#input file
text_path = '/Users/thomastiotto/Documents/USI/1 semester/Deep Learning Lab/clarissa_txt/diocane.txt'
# read input text and create dictionary
data, dict, rev_dict = read.read_file(text_path)
dict_size = len(dict)
# Parameters
learning_rate = 0.001
epochs = 2 #epochs
display_step = 1 #expressed in epochs
n_layers = 1
batch_size = 5
# number of units in RNN cell
n_hidden = 512
def encode(x, y):
x_enc = [dict[i] for i in x]
y_enc = [dict[y]]
#x_enc = np.array(x_enc)
from config import configer
from Alphabet import Alphabet
from train import train
import collections
from Common import *
import argparse
if __name__ == '__main__':
parse = argparse.ArgumentParser()
parse.add_argument('--config',
default='./config.cfg',
help='input the config path')
parse.add_argument('--use_cuda',
default=False,
help='if use cuda or not , default is false')
args = parse.parse_args()
config = configer(args.config)
train_data = read_file(config.train_data_path, split=True)
train_label = read_file(config.train_label_path, split=True)
test_data = read_file(config.test_data_path, split=True)
test_label = read_file(config.test_label_path, split=True)
dev_data = read_file(config.dev_data_path, split=True)
dev_label = read_file(config.dev_label_path, split=True)
word_alpha, label_alpha = createAlphabet(train_data, train_label,
config.word_cut_off)
alpha_tuple = (word_alpha, label_alpha)
corpus_tuple = (train_data, train_label, dev_data, dev_label, test_data,
test_label)
train(config, alpha_tuple, corpus_tuple)
# initialize
print("Starting up Pydoku...")
start = time.clock()
duration = 0
done = False
# parse command-line arguments
args = arg_parse.get_parser().parse_args() # get and run parser
no_solve, pretty_print, board, file_ = arg_parse.init(args) # init args
# read board
# if we were supplied a file, read it
if board:
print("Reading from file '{}'...".format(board.name))
board = read.read_file(board)
# else we have to get it from the user
else:
print("Enter the known numbers (leaving spaces for those you don't know)...")
now = time.clock()
board = read.read_stdin()
duration -= time.clock() - now
# solve board
if not no_solve:
print("Solving... ", end='')
board = solve.solve(board)
# check if we're done
if solve.done(board):
done = True
#!/usr/bin/python3 from read import read_file from sort import sorting from write import write_file # read in the input dataset file_name = './input/itcont.txt' list_drug, list_number, list_cost = read_file(file_name) # sort the list drug_sorted, number_sorted, cost_sorted = sorting(list_drug, list_number, list_cost) # write the output dataset file_write = './output/top_cost_drug.txt' write_file(file_write, drug_sorted, number_sorted, cost_sorted)
# -*- coding:utf-8 -*-
## SNL编译器前端
import sys
import symbol_list ## 字符表
import read ## 读文件
import lexeme ## 词法分析
import de_comment ## 去掉注释
import r_d_p ## 递归下降法
## 读取文件
source = read.read_file(sys.argv[1])
## 添加末尾的EOF
## source = source + " EOF"
## 去掉注释
processed = de_comment.de_comment(source)
## 把词法分析后的结果存入result列表中
result = lexeme.slice(processed)
## 词法分析输出部分
## 创建名为output的文件并把结果输入到文件中
output = open('lexical_analysis.txt', 'w')
for item in result:
output.write("%s\n" % item)
## 扫描token序列
r_d_p.scan(result)
import summarize
import process
import evaluate
import pandas as pd
import classifier
import pylab as pl
import numpy as np
import matplotlib.pyplot as plt
from sklearn import preprocessing
from sklearn import cross_validation
import scipy
TARGET_COL = 0
#### read data
df_train = read.read_file('data/cs-training.csv', index_col = 0)
df_test = read.read_file('data/cs-test.csv', index_col = 0)
columns = df_train.columns
#### seperate x and y variables from training and testing sets
X = df_train.copy()
y = X[columns[TARGET_COL]]
del X[columns[TARGET_COL]]
del df_test[columns[TARGET_COL]]
#### create histograms for each variable in input data
for col in columns:
summarize.histogram(df_train,col)
### summary tables
args = parser.parse_args()
tab_input = [
"a_example.txt",
"b_read_on.txt",
"c_incunabula.txt",
"d_tough_choices.txt",
"e_so_many_books.txt",
"f_libraries_of_the_world.txt",
]
hard_code_path_to_input = "/home/toromanoff/workspace/hashcode_2/input"
input_file = os.path.join(hard_code_path_to_input,
tab_input[args.input_file_indice])
num_days, book_scores, libs = read_file(input_file)
N_book = len(book_scores)
N_lib = len(libs)
N_days = num_days
list_time_registration_lib = [lib['sign_up_t'] for lib in libs]
tab_score_book = np.array(book_scores)
tab_book_library = [np.array(lib['book_ids']) for lib in libs]
print("N_book = ", N_book)
print("N_lib = ", N_lib)
print("N_days = ", N_days)
# print("list_time_registration_lib = ", list_time_registration_lib)
# print("tab_score_book = ", tab_score_book)
# print("tab_book_library = ", tab_book_library)
dict_schedule_solution[inters] = []
for ind_schedule in range(len(schedule)):
current_street_name = list_name_street[ind_schedule]
current_time_schedule = schedule[ind_schedule]
dict_schedule_solution[inters].append(
(current_street_name, current_time_schedule))
return dict_schedule_solution
#tab_file = ["a.txt","b.txt","c.txt","d.txt","e.txt","f.txt"]
tab_file = ["a.txt"]
for file in tab_file:
input_folder = "input"
name_file = file
streets, cars, duration, nb_inters, nb_streets, nb_cars, bonus = read_file(
os.path.join(input_folder, name_file))
duration = int(duration)
list_cars = cars
print("duration = ", duration)
start_time = time.time()
# print("time starting build_dict_inters_car = ", start_time)
tab_time_cars = compute_length_path_car(list_cars, streets)
indice_cars_usefull = np.where(tab_time_cars <= duration)[0]
list_cars_usefull = [
list_cars[indice_car_usefull]
for indice_car_usefull in indice_cars_usefull
]
full_dict_inters_car = build_dict_inters_car(list_cars_usefull, streets)
print("duration build_dict_inters_car = ", time.time() - start_time)
start_time = time.time()
class_index = 1
correct_predictions = 0
# Hyperparameters, tune as needed
alpha = 0.0001
epochMax = 1
hidden_layer_count = 1
hidden_node_count = 2 # Same number of hidden nodes per layer
output_node_count = 1
total_layer_count = hidden_layer_count + 1 # Add output layer
# User input, read and store input csv files
print("MULTILAYER PERCEPTRON \n")
train_file = input("Enter training csv file name: ")
test_file = input("Enter testing csv file name: ")
train_data = read.read_file(train_file, train_data)
test_data = read.read_file(test_file, test_data)
# Separate class labels from features
train_features = train_data[1:]
train_labels = [element[0] for element in train_data]
test_features = test_data[1:]
test_labels = [element[0] for element in test_data]
# Normalize feature values
train_features = [read.normalize(element) for element in train_features]
test_features = [read.normalize(element) for element in test_features]
# Store features row-wise, convert data to arrays
train_features = np.array(train_features)
train_labels = np.array(train_labels)
# tab_file = ["a.txt","b.txt","c.txt","d.txt","e.txt","f.txt"]
tab_file = [
# "a_an_example.in.txt",
# "b_better_start_small.in.txt",
"c_collaboration.in.txt",
"d_dense_schedule.in.txt",
"e_exceptional_skills.in.txt",
"f_find_great_mentors.in.txt"
]
for file in tab_file:
start_time = time.time()
input_folder = "input"
name_file = file
projects_done = []
projects_in_progress = []
contributors, projects_to_do, list_max_skill_needed, max_iteration = read_file(
os.path.join(input_folder, name_file))
projects_sorted = sort_project(projects_to_do, False)
iteration = 0
print("ProjectDone " + str(len(projects_done)))
print("ProjectInProgress " + str(len(projects_in_progress)))
print("ProjectToDo " + str(len(projects_sorted)))
print("iteration " + str(iteration))
print("contributor available " + str(len(contributors)))
string_progress = str(len(projects_done)) + "-" + str(
len(projects_in_progress)) + "-" + str(
len(projects_sorted)) + "-" + str(len(contributors))
string_progress_end = ""
while iteration < max_iteration + 5 or len(projects_to_do) == 0:
if iteration % 1000 == 0:
print("ProjectDone " + str(len(projects_done)))
def main(id_input):
B = 100
scanned_books = np.zeros(B)
hard_code_path_to_input = "/home/raphael/PycharmProjects/hashcode_2/input/"
tab_input = [
"a_example.txt",
"b_read_on.txt",
"c_incunabula.txt",
"d_tough_choices.txt",
"e_so_many_books.txt",
"f_libraries_of_the_world.txt",
]
num_days, book_scores, libs = read_file(hard_code_path_to_input +
tab_input[id_input])
days_left = num_days
for id_lib, lib in enumerate(libs):
lib["set_books"] = set(lib["book_ids"])
lib["id"] = id_lib
lib["set_books_with_score"] = set()
lib["taken"] = 0
score_in_lib = 0
for book in lib["book_ids"]:
lib["set_books_with_score"].add((book, book_scores[book]))
score_in_lib += book_scores[book]
lib["score_in_lib"] = score_in_lib
book_occurence = count_occurence(libs, book_scores)
STOP = False
number_output_libs = 0
global_output = ""
middle_output = ""
while not STOP and days_left > 0:
print(days_left)
id_best_lib = choose_library(libs,
days_left=days_left,
book_occurence=book_occurence)
if id_best_lib is None:
print("no more libs available")
break
lib_chosen = libs[id_best_lib]
book_occurence = update_book_occurence(book_occurence, lib_chosen)
days_left -= lib_chosen["sign_up_t"]
output_text, books_taken = choose_books_for_lib(lib_chosen, days_left)
if len(books_taken) > 0:
number_output_libs += 1
#print("before", libs)
libs = update_libs(libs, books_taken, book_scores)
middle_output += output_text
#print("after", libs)
global_output = "{}\n".format(number_output_libs) + middle_output
print("output_text", global_output)
result_file = hard_code_path_to_input + "result/result_" + tab_input[
id_input]
with open(result_file, 'w') as file:
file.write(global_output)
#module mane: main
import read
import purchase
import write
again = "Y"
while again.upper() == "Y":
a = read.read_file()
b = purchase.purchase(a)
write.over_write(a, b)
again = input("\nDoes the any new customer waiting to buy product? ")
print("\nThank you for shopping from our store!!")
print(
"Please check your invoice for your shopping details, \nWhich we created txt file format for you."
)
import warnings
warnings.warn = warn
import pandas as pd
import numpy as np
from sklearn.externals import joblib
import xgboost as xgb
import time
import pickle
import read as rd
data_file_path = './data/train_lag1_new.csv'
df = rd.read_file(data_file_path)
model_dict = {
0: 'Linear Regression',
1: 'SVR',
2: 'Random Forest',
3: 'XGBoost'
}
with open('selected_attr_list.txt', 'rb') as f:
selected_attr_list = f.read().split(',')
with open('selected_model_type.txt', 'rb') as f:
model_type = int(f.read().split(',')[0])
def train_model():
