def reset(ctx):
ctx.status("loading deployment config")
fp = os.path.join(_DEPLOYMENT_CONFIGS_DIR, args.deployment_config)
ctx.deployment_config = deployment_config.DeploymentConfig(
fp, get_provider_profiles())
ctx.status_ok()
load.load(ctx)
def process(path_to_ini: str):
""" Program main function """
input_paths, output_path = load_ini(path_to_ini)
records = Records()
load(records, input_paths["csv"], input_paths["json"],
input_paths["encoding"])
records.output(output_path["fname"], output_path["encoding"])
def test_load(self):
filename = "non-existent-file.txt"
# test a non-existent file
self.assertEqual(load(filename), "No save file exists.")
# see if a save file exists at all
filename = "save.txt"
self.assertTrue(os.path.exists(filename))
for trial in range(6):
if trial != 0:
save_file = open("save.txt", "w+")
save_file.write(str(trial))
save_file.close()
print("test is: " + str(trial))
self.assertEqual(load("save.txt"), "success")
bad_states = [-1, 50, 79, "egg"]
for trial in range(len(bad_states)):
save_file = open("save.txt", "w+")
save_file.write(str(bad_states[trial]))
save_file.close()
print("test is: " + str(bad_states[trial]))
self.assertEqual(
load("save.txt"),
"Save file is corrupted. Please start a new game.")
def load(self, path:str):
'''
loading of the dumped data
'''
if not path:
raise Exception('path is not defined')
load(path)
def init():
#初始化参数
self.clear()
self.downloaded = True
self.i = 0
self.len = 0
load.load()
self.ISBN = load.get_ISBN()
self.bookname = load.get_booname()
self._class = load.get_class()
self.publish = load.get_publish()
self.original_price = load.get_original_price()
self.dd_price = load.get_dd_price()
self.date = load.get_date()
self.goodrate = load.get_goodrate()
self.img = load.get_img()
self.author = load.get_author()
self.authorInfo = load.get_authorInfo()
self.customer = load.get_customer()
self.comment = load.get_comments()
self.content = load.get_content()
self.len = len(self.ISBN)
#print(len(self.ISBN))
if self.downloaded:
for i in range(self.len):
image_download.save(self.img[i], i)
self.downloaded = False
change()
def __init__(self, ori_data, loading, **kwarg):
"""
"""
self.ori_data = load(ori_data)
if not loading:
self.shap_data = kwarg.get('shap_data')
else:
self.shap_data = load(kwarg.get('shap_data'))
def main(ctx):
if ctx.args.reset:
ctx.status("loading deployment config")
fp = os.path.join(_DEPLOYMENT_CONFIGS_DIR, args.deployment_config)
ctx.deployment_config = deployment_config.DeploymentConfig(fp)
ctx.status_ok()
load.load(ctx)
find_claims(ctx)
def do_etl(echo=False, inital_load=False):
from load import load
from extraction import extraction
from transformation import transformation
run_id = extraction(echo=echo)
transformation(echo=echo, inital_load=inital_load, run_id=run_id)
load(echo=echo, run_id=run_id)
def __init__(self, data, read_file, mode):
if mode == 'Compute':
self.data = pd.DataFrame(data)
else:
self.data = load(data)
data = self.data.iloc[:, :-2]
data = data.applymap(lambda x: abs(x))
shap_mean = data.apply(lambda x: x.mean())
self.shap_mean = shap_mean.sort_values(ascending=True)
ori = load(read_file)
self.ori = ori.reindex(self.data.ID.values)
def loadAll(): files = ['data_batch_1','data_batch_2','data_batch_3','data_batch_4','data_batch_5'] path = '/home/dylan/Downloads/cifar-10-batches-py/' Xtr = load.load(path + 'data_batch_1')[0] Ytr = load.load(path + 'data_batch_1')[1] for i in range(1,len(files)): p = path + files[i] resx,resy = load.load(p) print Xtr.shape,resx.shape Xtr = np.concatenate((Xtr,resx)) Ytr = np.concatenate((Ytr,resy)) res = load.load(path + 'test_batch') return Xtr,Ytr,res[0],res[1]
def change_background(self):
if self.scenery == "outside":
self.game.fill(BLACK)
self.sound.play()
req_egg_text.__init__(295, 100,
("Required eggs: %s" % chicken.req_egg),
WHITE, "helvetica", 32)
req_egg_text.draw(gameCanvas.game)
nightText.draw(gameCanvas.game)
nightGame.__init__(300, 30, 250, 450, foodBarFront.width)
pygame.display.update()
pygame.time.wait(2000)
self.file = pygame.image.load(
'graphics//background2.png').convert()
self.file2 = pygame.Surface([self.width, self.height],
pygame.SRCALPHA, 32)
timeBarFront.width += 75
self.scenery = "inside"
if timeBarFront.width <= 1:
if self.scenery == "inside":
self.game.fill(BLACK)
self.sound.play()
chicken.egg_highscore += chicken.egg
if chicken.egg < chicken.req_egg:
if chicken.egg_highscore > load.load():
load.save(chicken.egg_highscore)
scoreText.__init__(300, 120,
("Score: %s" % chicken.egg_highscore),
WHITE, "helvetica", 45)
scoreText.draw(gameCanvas.game)
highscoreText = text.Text(290, 400,
("Highscore: %s" % load.load()),
WHITE, "helvetica", 45)
highscoreText.draw(gameCanvas.game)
gameOverAnim()
else:
dayText.draw(gameCanvas.game)
chicken.egg = 0
chicken.req_egg += 2
pygame.display.update()
pygame.time.wait(2000)
self.file = pygame.image.load(
'graphics//background.png').convert()
self.file2 = pygame.image.load(
'graphics//hegn.png').convert_alpha()
timeBarFront.next_level()
foodBarFront.next_level()
timeBarFront.reset()
foodBarFront.reset()
self.scenery = "outside"
def mainLoop():
global gameExit
highscoreText.__init__(300, 400, ("Highscore: %s" % load.load()),
(75, 180, 50), "helvetica", 30)
clock = pygame.time.Clock()
while not gameExit:
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameExit = True
pygame.quit()
menuCanvas.draw()
playButton.draw()
playText.draw(menuCanvas.canvas)
optionsButton.draw()
optionsText.draw(menuCanvas.canvas)
exitButton.draw()
exitText.draw(menuCanvas.canvas)
maxwellText.draw(menuCanvas.canvas)
highscoreText.draw(menuCanvas.canvas)
linctusText.draw(menuCanvas.canvas)
soundcloudText.draw(menuCanvas.canvas)
if menuCanvas.imageON == True:
menuCanvas.canvas.blit(optionsButton.image, menuCanvas.rect)
optionsCloseButton.draw()
optionsCloseText.draw(menuCanvas.canvas)
pygame.display.update()
clock.tick(60)
def dectree():
inputs,targets = load("../proc_data/data",equalize=False,shuffle=True)
train_split = 0.8
#Split between train and test
length = len(inputs)
split = int(length*train_split)
inputs_train = inputs[:split]
targets_train = targets[:split]
inputs_test = inputs[split:]
targets_test = targets[split:]
print length,"total inputs"
print len(inputs_train),"used for training"
print len(inputs_test),"used for testing"
start = time.time()
clf = tree.DecisionTreeClassifier(criterion="entropy",max_depth=6,random_state=42)
print "Training Tree..."
clf.fit(inputs_train, targets_train)
print "Training time:",time.time()-start
print "Predicting tests..."
start = time.time()
targets_predicted = clf.predict(inputs_test)
print "Classification time:",time.time()-start
print metrics.classification_report(targets_test, targets_predicted)
print "Saving classifier to disk..."
with open("../classifiers/tree","w") as clffile:
pickle.dump(clf,clffile)
def exitsavwar():
try:
filename
except:
exit()
else:
try:
stufftemp = {}
worldtemp = []
stufftemp, worldtemp = load(filename, stufftemp, worldtemp)
if stufftemp != stuff or worldtemp != world:
filewin = Toplevel(main)
label = Label(
filewin,
text=
"You have unsaved data, are you sure you want to continue?"
)
label.grid(row=0, columnspan=30, column=0)
dont = Button(filewin, text="yes", command=lambda: exit())
dont.grid(column=14, row=1)
yeah = Button(filewin,
text="no",
command=lambda: filewin.destroy())
yeah.grid(column=15, row=1)
else:
exit()
except:
exit()
def loads(self):
"""
将插件对象插入到线程池工作队列
"""
tempRes = load.load()
for mod in tempRes:
self.__tp.addTask(tempRes[mod])
def test_load3(self):
expected = {'you': {'say': {'test1': {'foo': 'bar'}}}}
actual = load(os.path.join(DATA_PATH, 'test3'))
logging.info('Expected: %s', str(expected))
logging.info('Actual: %s', str(actual))
self.assertEqual(expected, actual,
'Directory with Directory with file')
def button():
global dataset
print(dataset)
loaded = load(dataset)
return flask.render_template("query_result.html",
loaded=loaded,
loading=True)
def SHAPit():
if var_read.get():
df = load(var_read.get())
label = list(lb_label.get(0, tk.END))
feature = list(lb_feature.get(0, tk.END))
feature.extend(label)
data = df.loc[:, feature].copy()
data[label[0]] = data[label[0]].map(lambda x: str(x))
l = Loop(data,
label[0],
loop=var_loop.get(),
n_splits=var_splits.get(),
sample_mode=cmb.get(),
major_label=var_major.get(),
minor_label=var_minor.get())
out = l.Loop()
var_data.set(out.to_dict())
if not messagebox.askyesno('Finished!',
'Would you want to save the result?'):
savefile = asksaveasfilename(filetypes=(("Excel file",
"*.xlsx*;*.xls*"),
("csv file", "*.csv*"),
("Text file", "*.txt*")))
out.to_csv(savefile, index=False)
else:
pass
else:
pass
def Load(self):
data = load(self.loadfile)
self.df = data
# self.df = abs(self.df)
self.length = len(self.df)
self.hit_all = len(self.df[self.df[self.label_col] == 1])
self.scorers = pd.Series(self.score_col)
def pytest_generate_tests(metafunc):
args = []
for f in test_files:
rt = build_rt(os.path.basename(f))
for form in load(file(f)):
args.append((rt, form))
metafunc.parametrize(metafunc.funcargnames, args)
def test(n=10, use_fit_transform=True):
'''
Test BOW() object for n rows of the training dataset.
inputs:
- n (int): number of rows of the training dataset to test BOW formulation on
- use_fit_transform (bool): if True, test is done using the BOW.fit_transform() method, else use BOW.fit() then BOW.transform() separately
'''
import load
X_train, y_train, X_test, y_test = load.load(True, False, False, False)
bow = BOW()
if not use_fit_transform:
bow.fit(X_train, new_pickle=False)
output = bow.transform(X_train[0:n])
_using = 'fit() THEN tranform()'
else:
output = bow.fit_transform(X_train[0:n], new_pickle=False)
_using = 'fit_transform()'
print('Using {0}...\nWords found in each header/article\n'.format(_using),
np.sum(output, axis=1))
output = bow.fit_transform(X_train[0:n],
new_pickle=False,
separate_vectors=True)
print('Words in each header, then words in each article\n{0}\n{1}'.format(
np.sum(output[0], axis=1), np.sum(output[1], axis=1)))
def supvec():
inputs, targets = load("../proc_data/data", equalize=False)
train_split = 0.8
#Split between train and test
length = len(inputs)
split = int(length * train_split)
inputs_train = inputs[:split]
targets_train = targets[:split]
inputs_test = inputs[split:]
targets_test = targets[split:]
print length, "total inputs"
print len(inputs_train), "used for training"
print len(inputs_test), "used for testing"
start = time.time()
clf = svm.SVC(kernel="linear", verbose=False)
print "Training SVM..."
clf.fit(inputs_train, targets_train)
print "Training time:", time.time() - start
print "Predicting tests..."
start = time.time()
targets_predicted = clf.predict(inputs_test)
print "Classification time:", time.time() - start
print metrics.classification_report(targets_test, targets_predicted)
print "Saving classifier to disk..."
with open("../classifiers/svm", "w") as clffile:
pickle.dump(clf, clffile)
def draw_pr(file, label_col, Ascore_col, Dscore_col, figsize=(5, 5)):
data = load(file)
score_col = Ascore_col + Dscore_col
label = data.pop(label_col)
font_kws = {'family': 'arial', 'size': 18}
f, ax = plt.subplots(figsize=figsize)
for col in score_col:
score = data.loc[:, col]
if col in Ascore_col:
score = 1 - score
else:
pass
precision, recall, _ = precision_recall_curve(label,
score,
pos_label=1)
AUC = auc(recall, precision)
ax.plot(recall,
precision,
linewidth=1.5,
label=col + ' (auc=%.3f)' % AUC)
ax.set_title('Precision/Recall Curve') # give plot a title
ax.set_xlabel('Recall', fontdict=font_kws) # make axis labels
ax.set_ylabel('Precision', fontdict=font_kws)
ax.tick_params(direction='in', which='both', labelsize=12)
ax.set_ylim([0.0, 1.0])
ax.set_xlim([0.0, 1.0])
ax.legend(fontsize=6.5)
plt.show()
return f
def drawpr(folder_path='.',
label_field='Label',
score_field='average',
figsize=(5, 5),
ascending=False,
savedir=None):
files = os.listdir(folder_path)
font_kws = {'family': 'arial', 'size': 18}
f, ax = plt.subplots(figsize=figsize)
if ascending:
pos_label = 0
else:
pos_label = 1
i = 0
rounds = len(files)
length = 10
for file in files:
target = re.findall('\d\d_(.*?)_\w', file)[0]
data = load(os.path.join(folder_path, file))
label = data[label_field].values
score = data[score_field].values
precision, recall, _ = precision_recall_curve(label,
score,
pos_label=pos_label)
area = auc(recall, precision)
ax.plot(recall,
precision,
linewidth=1.5,
label='{} (AUC={})'.format(target, '%.3f' % area))
i += 1
ratio = i / rounds
num = int(length * ratio)
p = ''.join([
'|', '>' * num, '*' * (length - num), '|', ' ',
'{}%'.format(round(ratio * 100, 1))
])
print(p, end='\r')
ax.set_xlabel('Recall', fontdict=font_kws) # make axis labels
ax.set_ylabel('Precision', fontdict=font_kws)
ax.set_ylim([0.0, 1.0])
ax.set_xlim([0.0, 1.0])
ax.spines['bottom'].set_linewidth(1.3)
ax.spines['left'].set_linewidth(1.3)
ax.spines['top'].set_linewidth(1.3)
ax.spines['right'].set_linewidth(1.3)
ax.tick_params(direction='in', which='both', labelsize=12)
ax.legend(fontsize=6.5)
# ax.plot([0, 1], [0, 1], '--', color=(0.6, 0.6, 0.6), label='Random')
if savedir:
plt.savefig(savedir)
plt.show()
return f
def main():
try:
env = {}
for lib in ['stdlib.lisp', 'bq.lisp']:
with open(lib) as f:
try:
env.update(load(f, lib, env))
except (LoadError, LoadWarning) as e:
print_exception(e)
exit(2)
while True:
try:
expr = raw_input('* ')
except (KeyboardInterrupt, EOFError):
print
break
if not expr:
continue
try:
form = Reader(expr, '<string>').read()
result = eval_form(form, env)
except ReadError as e:
print_exception(e)
continue
if isinstance(result, Error):
print_error(result)
print pprint(result)
env[Symbol('_')] = result
except KeyboardInterrupt:
print
def __register_events():
p = os.path.join(os.environ['TATOOL'], r'Common\Tools\ImportModule')
if p not in sys.path:
sys.path.append(p)
import load
project_path = '%s/../../Tools/' % os.path.dirname(
os.path.realpath(__file__))
for path in os.listdir(project_path):
register_event_script_path = '%s/%s/Package/Scripts/registerEvents' % (
project_path, path)
if os.path.exists(register_event_script_path +
'.py') or os.path.exists(register_event_script_path +
'.pyc'):
load.load('register_events', register_event_script_path)
def submission(fname_net='net2.pickle'):
with open(fname_net, 'rb') as f:
net = pickle.load(f) # net = specialists
X = load.load(test=True)[0]
y_pred = net.predict(X)
print 'Finish predicting test file'
columns = 'left_eye_center_x,left_eye_center_y,right_eye_center_x,right_eye_center_y,left_eye_inner_corner_x,left_eye_inner_corner_y,left_eye_outer_corner_x,left_eye_outer_corner_y,right_eye_inner_corner_x,right_eye_inner_corner_y,right_eye_outer_corner_x,right_eye_outer_corner_y,left_eyebrow_inner_end_x,left_eyebrow_inner_end_y,left_eyebrow_outer_end_x,left_eyebrow_outer_end_y,right_eyebrow_inner_end_x,right_eyebrow_inner_end_y,right_eyebrow_outer_end_x,right_eyebrow_outer_end_y,nose_tip_x,nose_tip_y,mouth_left_corner_x,mouth_left_corner_y,mouth_right_corner_x,mouth_right_corner_y,mouth_center_top_lip_x,mouth_center_top_lip_y,mouth_center_bottom_lip_x,mouth_center_bottom_lip_y'
columns = columns.split(',')
y_pred = y_pred * 48 + 48
y_pred = y_pred.clip(0, 96)
df = DataFrame(y_pred, columns=columns)
lookup_table = read_csv(os.path.expanduser('./data/IdLookupTable.csv'))
values = []
for index, row in lookup_table.iterrows():
values.append((
row['RowId'],
df.ix[row.ImageId - 1][row.FeatureName],
))
now_str = datetime.now().isoformat().replace(':', '-')
submission = DataFrame(values, columns=('RowId', 'Location'))
filename = 'submission-{}.csv'.format(now_str)
submission.to_csv(filename, index=False)
print("Wrote {}".format(filename))
def setUp(self):
self.l = load("intents.json")
self.data = self.l.getData()
for t in self.data["intents"]:
if t['tag'] == "greeting":
self.responses = t['responses']
if t["tag"] == "music":
self.responsesmusic = t['responses']
def va(request):
keyW = request.GET.get('varity', default='热血')
list = []
list = load.load(list, keyW)
random.shuffle(list)
resp = {'data': list}
return HttpResponse(json.dumps(resp), content_type="application/json")
def main():
gs, gs_target = load()
#envSettings = dict(MKL_NUM_THREADS=1, NUMEXPR_NUM_THREADS=1, OMP_NUM_THREADS=1)
with timed_block('TP penalty gauge opt'):
gs_gaugeopt = pygsti.gaugeopt_to_target(gs, gs_target,
item_weights={'spam' : 0.0001, 'gates':1.0},
TPpenalty=1.0)
def create_embeddings(self, image_folder):
features_deque = deque()
names_deque = deque()
for raw_images, file_paths, total in load(image_folder):
features_deque.extend(self.get_features(raw_images))
names_deque.extend(file_paths)
return np.array(names_deque, np.unicode_), \
np.array(features_deque, np.float32)
def main():
dat = load.load()
x = dat[:, 1]
y = dat[:, 2]
tmp = matmake(x, y, 3)
display(x, y, calc(tmp[0], tmp[1]), 3)
def main():
try:
cmd = sys.argv[1]
assert(cmd in cmds)
except:
invocations = ["python pypitches.py {0}".format(cmd) for cmd in cmds]
print "usage: " + "\n ".join(invocations)
sys.exit()
if cmd == 'initdb':
setup_postgres.initdb(postgres_db, postgres_user, postgres_password)
sys.exit()
else:
import model
model.SessionManager.create(postgres_db, postgres_user, postgres_password)
import load
from web.app import app
import select_gamedirs
from plot_pitch_locations import do_plots
if cmd == 'web':
app.run()
elif cmd == 'webtest':
app.run('pypitchestest', 'pypitches', 'slider')
elif cmd == 'ipython':
embed()
elif cmd == 'file':
# will generate output by a config file
# a la plot_pitch_locations.py
assert len(sys.argv) > 2, "usage: python pypitches.py file file.yaml"
do_plots(sys.argv[2])
elif cmd == 'download':
# hit the MLBAM server and get it all
pass
elif cmd == 'classify':
with model.SessionManager.get().begin_nested():
static_dir = sys.argv[2]
select_gamedirs.classify_local_dirs_by_filesystem(static_dir)
model.SessionManager.commit()
elif cmd == 'load':
statuses=set(sys.argv[2:]) or set(['final'])
with model.SessionManager.get().begin_nested():
load.load(statuses)
model.SessionManager.commit()
def main():
X, Y = load('train.csv')
adaboost = AdaBoostClassifier(n_estimators=150, learning_rate=0.1)
adaboost.fit(X, Y)
X_test, ID = loadTest('test.csv')
target = adaboost.predict_proba(X_test)
df = pandas.DataFrame()
df['TARGET'] = target[:,1]
df.index = pandas.Series(ID, name='ID')
df.to_csv('sumbit.csv')
def __init__(self, remoteShell, domainAdmin="admin", domain=None):
self.remoteShell = remoteShell
self.vastoolPath = "/opt/quest/bin/vastool"
self.domainAdmin = domainAdmin
self.defaultDomain = domain
self.info = info.info(self.run)
self.flush = flush.flush(self.run)
self.create = create.create(self.run, self.defaultDomain)
self.delete = delete.delete(self.run)
self.timesync = timesync.timesync(self.run)
self.nss = nss.nss(self.run)
self.group = group.group(self.run)
self.isvas = isvas.isvas(self.run)
self.list = list.list(self.run)
self.auth = auth.auth(self.run, self.defaultDomain)
self.cache = cache.cache(self.run)
self.configure = configure.configure(self.run)
self.configureVas = configureVas.configureVas(self.run)
self.schema = schema.schema(self.run)
self.merge = merge.merge(self.run)
self.unmerge = unmerge.unmerge(self.run)
self.user = User.user(self.run)
self.ktutil = ktutil.ktutil(self.run)
self.load = load.load(self.run)
self._license = License.License(self.run)
self.License = self._license.License
self.parseLicense = self._license.parseLicense
self.compareLicenses = self._license.compareLicenses
#self.vasUtilities = vasUtilities.vasUtilities(self.remoteShell)
self.unconfigure = unconfigure.unconfigure(self.run)
self.nssdiag = nssdiag(self.run)
isinstance(self.info, info.info)
isinstance(self.flush, flush.flush)
isinstance(self.create, create.create)
isinstance(self.delete, delete.delete)
isinstance(self.timesync, timesync.timesync)
isinstance(self.nss, nss.nss)
isinstance(self.group, group.group)
isinstance(self.isvas, isvas.isvas)
isinstance(self.list, list.list)
isinstance(self.auth, auth.auth)
isinstance(self.cache, cache.cache)
isinstance(self.configure, configure.configure)
isinstance(self.configureVas, configureVas.configureVas)
isinstance(self.schema, schema.schema)
isinstance(self.merge, merge.merge)
isinstance(self.unmerge, unmerge.unmerge)
isinstance(self.user, User.user)
isinstance(self.ktutil, ktutil.ktutil)
isinstance(self.load, load.load)
#isinstance(self.vasUtilities, vasUtilities.vasUtilities)
isinstance(self.unconfigure, unconfigure.unconfigure)
isinstance(self.nssdiag, nssdiag)
def main():
from load import load
import matplotlib.pyplot as plt
im = load('data/doodle.txt')
plt.imshow(im)
plt.show()
from tom import sol1
test = sol1(im)
return test
def loads(self):
"""
将插件对象插入到线程池工作队列
"""
tempRes = load.load()
self.maxCount = len(tempRes) # 赋值最大任务数
if self.maxCount == 0:
return False
for mod in tempRes:
self.__tp.addTask(tempRes[mod])
return True
def main():
X, Y = load('train.csv')
boost = GradientBoostingClassifier(n_estimators=150,verbose=1, max_features=8, max_depth=3)
boost.fit(X, Y)
X_test, ID = loadTest('test.csv')
target = boost.predict_proba(X_test)
df = pandas.DataFrame()
df['TARGET'] = target[:,1]
df.index = pandas.Series(ID, name='ID')
df.to_csv('sumbit.csv')
def compete(submit=False, history=10):
test = load('test.csv')
predicted = []
beta0 = None
i = 0
for month, month_test in test.groupby('monthage'):
i += 1
#if i != 20:
# continue
month_test = month_test.copy()
# Use only last history months.
#month_train = train[(train['monthage'] <= month) & (train['monthage'] > month - history)]
month_train = train[train['monthage'] <= month]
nbsm = NonlinearBikeShareModel(month_train)
#if beta0 is None:
# beta0 = nbsm.beta0()
res = optimize.minimize(nbsm, nbsm.beta0(), method='L-BFGS-B', jac=True, bounds=nbsm.bounds(), options={'disp': False, 'maxiter': 10000})
#res = optimize.basinhopping(
# nbsm,
# nbsm.beta0(),
# minimizer_kwargs={
# 'method':'L-BFGS-B',
# 'jac':True,
# 'bounds': nbsm.bounds(),
# 'options': {'disp': False, 'maxiter': 500}
# },
# disp=True,
# niter=10
#)
print '%s training error:' % month, nbsm(res.x)[0]
month_test['count'] = nbsm.predict(month_test, res.x)
#nbsm.show(res.x)
predicted.append(month_test)
#beta0 = res.x
predicted = pandas.concat(predicted)
plt.plot_date(train['dates'], train['count'], label='train')
plt.plot_date(predicted['dates'], predicted['count'], label='predicted')
plt.legend()
plt.show()
plt.clf()
if submit:
submission = pandas.DataFrame()
submission['datetime'] = test['dates']
submission['count'] = predicted['count'] #.round().astype('int')
submission.to_csv('submission-' + datetime.datetime.now().strftime('%Y-%m-%d-%H-%M') + '.csv', index=False)
def calorie(items, quantity):
food = load()
totalCal = 0
totalQuantity = 0
for i in range(len(items)):
for j in range(len(food.items)):
l = food.items[j].split(',')
if l[0].split('\"')[1] == items[i]:
totalCal = totalCal + int(l[2].split("\"")[1]) * int(quantity[i])
totalQuantity = totalQuantity + int(quantity[i])
return ( float(totalCal) / float(totalQuantity) )
def plot(self, filename, centroid, step):
X = load(filename)
dist = [[norm(x-c) for c in centroid] for x in X]
clusters = np.argmin(dist, 1)
cm = get_cmap('jet', self.K)
fig = plt.figure()
plt.scatter(X[:,0], X[:,1], marker = 'o', c=clusters, cmap=cm)
plt.scatter(centroid[:,0], centroid[:,1], marker='o', linewidths=10)
fig.show()
plt.savefig('../figures/'+self.name +'_' + step + '.eps')
def main():
data = load('bank-additional-full.csv')
tot_no_rows = len(data)
col_names = ["age", "job", "marital", "education", "default", "housing", "loan", "contact", "month", "day_of_week", "duration", "campaign", "pdays", "previous", "poutcome", "empvarrate", "conspriceidx", "consconfidx", "euribor3m", "nremployed" , "y"]
accuracy = np.empty([10, ], dtype = float )
no_of_iteration = 10
for i in xrange(no_of_iteration):
accuracy[i] = do_computation(data, col_names, tot_no_rows)
print accuracy
mean = np.mean(accuracy)
st_dev = np.std(accuracy)
print mean, st_dev
'''for key in unique_yes.keys():
def run(dataset=None, filename=None, path="./Data", sep=",", minsupport=0.1, min_factor=0.5):
# reading binarize file(changing binarize file into transaction)
filepath = path + "/" + dataset + "/" + filename
load.load(dataset=dataset, filename=filename)
# reading binarized transactions
transpath = path + "/" + dataset + "/" + "trans.json"
with open(transpath, "r") as fp:
d = json.load(fp)
# running apriori with minsupport to get frequency sets
l, support_data, c, f = apriori.apriori(d, minsupport=0.1)
# print("l is",l)
# print("support is",support_data)
# printing frequency set with support
"""
filepath=path + "/" + dataset + "/support_" + str(minsupport) + ".csv"
writer = csv.writer(open(filepath, 'wb'))
for key, value in support_data.items():
writer.writerow([list(key)[:], value])
"""
# generating maximal and closed itemset
print("# of candidate itemset is", c)
print("# of frequent itemset is", f)
s, sc = maximal_itemset.maximal(l)
print("# of maximal frequent itemset", sc)
c, cc = closed_itemset.closed(l, support_data)
print("# of closed frequent itemset is", cc)
# print("support data is",support_data)
# mining.generateRules(l,support_data)
# generating rules
# min_lift=min_factor
# rules,noofrules=mining_lift.generateRules(l,support_data,min_factor=0.85)
"""
def demo():
"""This is use-cases registry
"""
aligned_sents = load('../../data/giza/alignment-en-fr', 'latin_1')
use_case_1(aligned_sents)
print
use_case_2(1, 1, aligned_sents)
print
use_case_3(aligned_sents)
print
use_case_4(aligned_sents)
print
use_case_5(aligned_sents)
print
use_case_6(aligned_sents)
print
use_case_7()
print
use_case_8(aligned_sents)
def test_load_file(self):
with open("constant.bp") as f:
self.assertEqual(
load.load(f),
[
"@label@;constant",
"@forcing_function@;1.",
"@ideal@;0.5 * @forcing_function@ * ((x - x_l)**2 - "
"(x - x_l)*(x_r - x_l)) + u_l + u_r * "
"(x - x_l) / (x_r - x_l)",
"@n@;11",
"@label@;default",
"@forcing_function@;1.",
"@x_l@;0.",
"@x_r@;1.",
"@u_l@;0.",
"@u_r@;0",
"@n@;11",
],
)
def load(self, scope, stream):
for sexp in load(stream):
self.execute(scope, sexp)
import numpy as np
import re
from load import load
arr = load('data/doodle.txt')
n = arr.shape[0]
m = arr.shape[1]
arr2 = np.zeros((n, m))
with open('output2.txt') as f:
instr_nbr = int(f.readline())
instr_it = f.readlines()
for i, instr in enumerate(instr_it):
line = instr.split(' ')
if(line[0] == "PAINTSQ"):
r = int(line[1])
c = int(line[2])
s = int(line[3])
for k in range (-s,s+1):
for p in range (-s, s+1):
arr2[r+k][c+p] = 1
elif(line[0] == "ERASECELL"):
r = int(line[1])
c = int(line[2])
arr2[r][c] = 0
result = True
for k in range (0,n):
for p in range (0,m):
result = result & (arr[k,p] == arr2[k,p])
import SETTINGS
import logging
import sqlaload as sl
from extract import extract
from entities import create_entities, update_entities
from load import load
from setup import setup, make_grano
from transform import transform
from network_entities import update_network_entities
if __name__ == '__main__':
import sys
logging.basicConfig(level=logging.DEBUG)
assert len(sys.argv) == 3, "Usage: %s [ir_source_file] [ap_source_file]"
ir_source_file = sys.argv[1]
ap_source_file = sys.argv[2]
engine = sl.connect(SETTINGS.ETL_URL)
extract(engine, ir_source_file, ap_source_file)
update_network_entities(engine, 'network_entities.csv')
create_entities(engine)
update_entities(engine, 'entities.csv')
transform(engine)
grano = make_grano()
setup(engine, grano)
load(engine, grano)
import numpy as np
test = [[48.838566,2.332006], [48.830487,2.356382], [48.850484,2.283855],
[48.873071,2.294498], [48.891527,2.334667], [48.887972,2.379814],
[48.867594,2.40007], [48.861553,2.335525]]
test = np.array(test)
def find_spread_point(G, N):
sp = np.zeros(8)
min_d = np.ones(8)*100000000000000
for i in range(N):
for j in range(8):
l = sum((G.node[i]['pos'] - test[j])**2)
if min_d[j] > l:
min_d[j] = l
sp[j] = i
return sp
if __name__ == '__main__':
from load import load
G, params = load()
s_points = find_spread_point(G, params[0])
print 'CSE 5243 Similarity Analysis by Kun Liu & Zhe Dong'
import load
import minhash
import time
begin_time=time.time()
(Data, SparseData, Cnt, rdim, cdim) = load.load()
#convert data into 0/1
#for i in range(0, rdim):
# for j in range(0, cdim):
# if Data[i][j] != 0:
# Data[i][j] = 1
#print "done1"
#import sklearn.metrics.pairwise
#Pair_Wise_Dist = sklearn.metrics.pairwise.pairwise_distances(Data,metric='jaccard')
#print "done2"
#Mean Squared Error
def similarity_MSE(true_sim, hash_sim):
mse = 0
for i in range(0,len(true_sim)):
for j in range(0, len(true_sim[i]) ):
mse += pow(true_sim[i][j] - hash_sim[i][j],2)
return mse / len(true_sim)/len(true_sim[0])
#compute true similarity
input_shape=(None, 9216), # 96x96 input pixels per batch
hidden_num_units=100, # number of units in hidden layer
output_nonlinearity=None, # output layer uses identity function
output_num_units=28, # 28 target values
# optimization method:
update=nesterov_momentum,
update_learning_rate=0.005,
update_momentum=0.9,
regression=True, # flag to indicate we're dealing with regression problem
max_epochs=400, # we want to train this many epochs
verbose=1,
)
X, y = load()
print "Done loading"
print("X.shape == {}; X.min == {:.3f}; X.max == {:.3f}".format(
X.shape, X.min(), X.max()))
print("y.shape == {}; y.min == {:.3f}; y.max == {:.3f}".format(
y.shape, y.min(), y.max()))
net1.fit(X, y)
# Training for 400 epochs will take a while. We'll pickle the
# trained model so that we can load it back later:
import cPickle as pickle
with open('net1.pickle', 'wb') as f:
pickle.dump(net1, f, -1)
train_loss = np.array([i["train_loss"] for i in net1.train_history_])
valid_loss = np.array([i["valid_loss"] for i in net1.train_history_])
import tensorflow as tf
import numpy as np
from load import load
from collections import defaultdict
import random
epoch_count = 10
batch_size = 128
alphabet = "abcdefghijklmnopqrstuvwxyz0123456789-,;.!?:'\"/\\|_@#$%^&*~`+-=<>()[]{}"
alphabet_size = len(alphabet)
max_text_len = 1014
class_num, train_set, test_set = load("AG", alphabet, max_text_len)
# char cnn
def weight_init(shape):
initial = tf.random_normal(shape, mean=0.0, stddev=0.02, dtype=tf.float32)
return tf.Variable(initial)
# batch x max_text_len
x = tf.placeholder(tf.int32, [None, max_text_len])
y = tf.placeholder(tf.int32, [None])
x_onehot = tf.one_hot(x, alphabet_size)
y_onehot = tf.one_hot(y, class_num)
hidden_size = 20
input_list = tf.unpack(x_onehot, axis=1)
cell = tf.nn.rnn_cell.GRUCell(hidden_size)
# state = cell.zero_state(...)
import os
import sys
from load import load
for root, dirs, files in os.walk(sys.argv[1]):
for f in files:
load(root + '/' + f)
print 'CSE 5243 Associate Rule Analysis by Kun Liu & Zhe Dong'
#load data
import load
(Data,Label,cdim) = load.load()
for i in range(0,5):
#split data
Train_Data = []
Train_Label = []
for j in range(0,5):
if j!=i:
Train_Data += Data[j]
Train_Label += Label[j]
Test_Data = Data[i]
Test_Label = Label[i]
#convert data into apriori format
F1 = open('train'+str(i), 'w')
for j in range(0, len(Train_Data)):
#print 'doc #' + str(j) + ' with ' + str(len(Train_Data[j])) + 'keywords'
for k in range(0, len(Train_Data[j])):
F1.write(str(Train_Data[j][k]) + ' ')
F1.write(Train_Label[j] + '\n')
#generate appearance.txt
F2 = open('appearance'+str(i), 'w')
F2.write('antecedent\n')
Label_Set = set(Train_Label)
for label in Label_Set:
from load import load
from rt import RT, LispException
import sys, os.path
from argparse import ArgumentParser
if __name__ == "__main__":
arg_parser = ArgumentParser(description = "Run you a lisp!")
arg_parser.add_argument("file", nargs = "?", help = "Lolisp source file to run")
args = arg_parser.parse_args()
rt = RT()
rt.load(rt.ns, file(os.path.join(sys.path[0], "rt.loli")))
if args.file:
rt.load(rt.ns, file(args.file))
else:
while 1:
print ">>> ",
s = sys.stdin.readline()
if not s:
break
sexps = load(s)
for sexp in sexps:
try:
print "=> %s" % repr(rt.execute(rt.ns, sexp))
except LispException as e:
print "***", str(e)
import cPickle as pickle
from pyhsmm.util.text import progprint_xrange
from pyhsmm.util.stats import whiten, cov
import autoregressive.models as models
import autoregressive.distributions as distributions
from load import load
np.random.seed(0)
### load
data = load()
data = whiten(data - data.mean(0))
ndim = data.shape[1]
### model
Nmax = 20
affine = True
nlags = 1
model = models.FastARWeakLimitStickyHDPHMM(
alpha=10., gamma=10.,
kappa=1e4,
init_state_distn='uniform',
obs_distns=[
def __init__(self):
self.t = init_t
self.count = 0
def clearCount(self):
self.count = 0
def updateT(self, total_f):
t_history = self.t
self.t = self.count / total_f
return abs(t_history - self.t)
if __name__ == "__main__":
# The collection of alignedSent should be provided by other team
aligned_sents = load('../../data/giza/alignment-en-fr', 'latin_1')
# generate word sets from corpus
e = set()
f = set()
for aligned_sent in aligned_sents:
for e_w in aligned_sent.sent1:
e.add(e_w)
for f_w in aligned_sent.sent2:
f.add(f_w)
f.add(NULL_TOKEN)
entry_count = len(e) * len(f)
e_given_f = defaultdict(TableCell)
total = defaultdict(float)
s_total = defaultdict(float)
l = line.split(',')
l = l[0].split("\"")
if l[1] != name:
ans = ans + copy
else:
print "Match Found!!! Entry Deleted!!!"
fp.close()
os.remove("./files/basicItems.csv")
fp = open("./files/basicItems.csv", 'w+')
fp.write(ans)
fp.close()
@staticmethod
def search(keyword):
print "Entries Found:"
fp = open("./files/basicItems.csv", 'r+')
for line in fp:
l = line.split(',')[1].split('\"')[1].split(':')
if any(keyword in s for s in l):
print line,
fp.close()
a = basic()
a.search("fruit")
#a.storeFood("ddsd", "122")
#a.readFood("jam")
#a.deleteFood("jam")
b = load()
