def plot_labeled_indexes(self,X_transformed,Y,W,labeledIndexes,title="labeled indexes"):
#Plot 1: labeled indexes
if self.args["can_plot"]:
vertex_opt = plt.vertexplotOpt(Y=Y,mode="discrete",size=7,labeledIndexes=labeledIndexes)
plt.plotGraph(X_transformed,plot_dim=2,W=W, vertex_opt= vertex_opt,edge_width=1,\
interactive = False,title=title)
def experiment_LDST(self,X_transformed,Y,W,labeledIndexes, mu = 99.0, tuning_iter=2, plot=True,Y_noisy=None):
if Y_noisy is None:
Y_noisy = Y
classif_LDST, Y_tuned, l_tuned = self.LDST(W=W, Y=Y_noisy, mu=mu, labeledIndexes=labeledIndexes,tuning_iter=tuning_iter)
classif_LDST = np.argmax(classif_LDST,axis=1)
if self.args["can_plot"] and plot:
''' PLOT Tuned Y '''
vertex_opt = plt.vertexplotOpt(Y=Y_tuned,mode="discrete",size=7,labeledIndexes=l_tuned)
plt.plotGraph(X_transformed,plot_dim=2,W=W, vertex_opt= vertex_opt,edge_width=1,\
interactive = False,title="LDST: Tuned Y")
''' PLOT LDST result '''
vertex_opt = plt.vertexplotOpt(Y=classif_LDST,mode="discrete",size=7)
plt.plotGraph(X_transformed,plot_dim=2,W=W, vertex_opt= vertex_opt,edge_width=1,\
interactive = False,title="LDST result")
acc = gutils.accuracy(classif_LDST, Y)
return acc
def experiment_LP(self,X_transformed,Y,W,labeledIndexes, plot=True,Y_noisy=None ):
if Y_noisy is None:
Y_noisy = Y
classif_LP = np.argmax(self.LP(W=W, Y=Y_noisy, labeledIndexes=labeledIndexes),axis=1)
if self.args["can_plot"] and plot:
vertex_opt = plt.vertexplotOpt(Y=classif_LP,mode="discrete",size=7)
plt.plotGraph(X_transformed,plot_dim=2,W=W, vertex_opt= vertex_opt,edge_width=1,\
interactive = False,title="LP result")
acc = gutils.accuracy(classif_LP, Y)
return acc
def experiment_RF(self,X,X_transformed,Y,W,labeledIndexes, plot=True,Y_noisy=None):
if Y_noisy is None:
Y_noisy = Y
#RF Classifier
rf = RandomForestClassifier(n_estimators=100).fit(X[labeledIndexes,:],Y_noisy[labeledIndexes])
rf_pred = np.array(rf.predict(X))
if self.args["can_plot"] and plot:
vertex_opt = plt.vertexplotOpt(Y=rf_pred,mode="discrete",size=7)
plt.plotGraph(X_transformed,plot_dim=2,W=W, vertex_opt= vertex_opt,edge_width=1,\
interactive = False,title="RF result")
acc = gutils.accuracy(rf_pred, Y)
return acc
def question_1():
# Specify hyper-parameters
agent = Agent()
environment = Environment()
rlglue = RLGlue(environment, agent)
num_episodes = 200
num_runs = 50
max_eps_steps = 100000
steps = np.zeros([num_runs, num_episodes])
for r in range(num_runs):
print("run number : ", r)
rlglue.rl_init()
for e in range(num_episodes):
#print("Episode number: "+str(e))
rlglue.rl_episode(max_eps_steps)
steps[r, e] = rlglue.num_ep_steps()
#print("Number of steps: "+str(steps))
# print(steps[r, e])
np.save('steps', steps)
plotGraph()
del agent, environment, rlglue
agent = Agent()
environment = Environment()
rlglue = RLGlue(environment, agent)
num_episodes = 1000
num_runs = 1
max_eps_steps = 100000
steps = np.zeros([num_runs, num_episodes])
for r in range(num_runs):
print("run number : ", r)
rlglue.rl_init()
for e in range(num_episodes):
print("Episode number: "+str(e))
rlglue.rl_episode(max_eps_steps)
steps[r, e] = rlglue.num_ep_steps()
#print("Number of steps: "+str(steps))
# print(steps[r, e])
#np.save('steps', steps)
#plotGraph()
rlglue.rl_agent_message("plot3DGraph")
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-a", dest="a",help="Part 'a' of elliptical curve: y^2 = x^3 + ax + b")
parser.add_argument("-b", dest="b",help="Part 'b' of elliptical curve: y^2 = x^3 + ax + b")
parser.add_argument("-x1",dest="x1",help="")
parser.add_argument("-y1",dest="y1",help="")
parser.add_argument("-x2",dest="x2",help="")
parser.add_argument("-y2",dest="y2",help="")
args = parser.parse_args()
# converting input of type strings to fractions
a=f.Fraction(args.a)
b=f.Fraction(args.b)
x1=f.Fraction(args.x1)
y1=f.Fraction(args.y1)
x2=f.Fraction(args.x2)
y2=f.Fraction(args.y2)
# checking whether points lie on the elliptical curve or not
checkFlag = p.checkPointsOnCurve(x1,y1,x2,y2,a,b)
# If boolean value is true do the following
if(checkFlag):
# comparing (x1,y1) and (x2,y2) if they are not equal normal slope value will be calculated
#or else differential slope will be calculated
p.compareCoordinates(x1,y1,x2,y2,a)
#finding x3 value by substituting values of m,x1,x2 in equation
x3 = p.getNewXValue(x1,y1,x2,y2)
#finding y3 value by substituting values of m,x3,x1,y1 in equation
y3= p.getNewYValue(x1,y1,x2,y2,x3)
# printing x3,y3 values
print("Value of x3 value is :",x3)
print("Value of y3 value is :",y3)
#plotting graph
p.plotGraph(x1,y1,x2,y2,x3,y3,a,b)
def main():
data=[]
pts=[]
# q = myutils.genRandomPoint(lowerBnd, upperBnd)
q = myutils.Point(500,500,0)
# ****************
# all points randomly generated
# ****************
# jobs = (N+jobSize-1)/jobSize
# for x in xrange(0,jobs):
# ptSet = []
# for y in xrange(0,jobSize):
# p = myutils.genRandomPoint(lowerBnd, upperBnd)
# ptSet.append(p)
# pts.append(p)
# # myutils.dispPoint(rand)
# ptSet.append(q)
# data.append(ptSet)
# ****************
# 3 almost circular clusters with random points
# ****************
jobs = (N+jobSize-1)/jobSize
for x in xrange(0,jobs):
ptSet = []
for y in xrange(0,5*jobSize/12):
p = myutils.genRandomPtCircle(10000, myutils.Point(10,10,-1), 1)
ptSet.append(p)
pts.append(p)
for y in xrange(0,5*jobSize/12):
p = myutils.genRandomPtCircle(10000, myutils.Point(-15000,-15000,-1), 2)
ptSet.append(p)
pts.append(p)
for y in xrange(0,jobSize/6):
p = myutils.genRandomPtCircle(1000, myutils.Point(100,100,-1), 0)
ptSet.append(p)
pts.append(p)
ptSet.append(q)
data.append(ptSet)
datasource = dict(enumerate(data))
print "Done"
s = mincemeat.Server()
s.datasource = datasource
s.mapfn = mapfn
s.reducefn = reducefn
results = s.run_server(password="******")
freq = []
for x in xrange(0,C):
freq.append(0)
for pt in results[0]:
myutils.dispPoint(pt[0])
freq[pt[0][2]] = freq[pt[0][2]]+1
predClass = freq.index(max(freq))
print predClass
plot.plotGraph(pts,myutils.Point(q[0],q[1],predClass))
#For example the node x will be in (0,0) position
position = {
'x': [0, 0],
'y': [2, 0],
'z1': [1, 1],
'z2': [0, 1],
'z3': [0, 2],
'z4': [2, 2],
'z5': [2, 1],
'z6': [1, 0]
}
#Draw up the list of node and define the graph
nodeList = [X, Y, Z1, Z2, Z3, Z4, Z5, Z6]
G = graph('G', nodeList, DAG=nodeout, pos=position)
#Plot the graph
plot.plotGraph(G)
#Plot all possible path between two node
plot.allPathPlot(G, X, Y)
#Define if between two variable there are backdoor path
BackDoor = bk.backdoor(G, X, [Z1, Z2], Y, Plot=True)
#Define if between two variable there are frontdoor path
FrontDoor = front_door.frontdoor(G, X, [Z6], Y, PlotAll=True)
# =============================================================================
#
# X=node('x')
# Y=node('y')
# U=node('u')
# S=node('s')
#
# X.set_nodein([U])
# Y.set_nodein([S, U])
def go(_):
ds_dict = {}
nxt_dict = {}
it_dict = {}
bs_dict = {
"labeled": FLAGS.batch_size,
"unlabeled": FLAGS.ul_batch_size,
"test": FLAGS.ul_batch_size
}
size_dict = {"labeled": FLAGS.num_labeled}
writer_dict = {}
example_shape = None
g1 = tf.Graph()
with g1.as_default():
with tf.device("/gpu:0"):
with tf.variable_scope("Vars", reuse=tf.AUTO_REUSE):
print("Reading dataset...")
if FLAGS.dataset == "cifar10":
cifar_dict = load_whole_dataset(os.path.join(
FLAGS.dataset_dir, "train.tfrecords"),
get_images=False,
get_zcas=True,
get_labels=True,
get_emb=False,
ds_size=50000)
train_X = cifar_dict.pop("zca")
train_Y = cifar_dict.pop("label")
size_dict["X_shape"] = list(train_X[0, :].shape)
size_dict["Y_shape"] = list(train_Y[0, :].shape)
cifar_dict = load_whole_dataset(os.path.join(
FLAGS.dataset_dir, "test.tfrecords"),
get_images=False,
get_zcas=True,
get_labels=True,
get_emb=False,
ds_size=10000)
test_X = cifar_dict.pop("zca")
test_Y = cifar_dict.pop("label")
ds_dict["test"] = tf.data.Dataset.from_tensor_slices({
"X":
test_X,
"Y":
test_Y
})
size_dict["test"] = test_X.shape[0]
elif FLAGS.dataset == "svhn":
svhn_dict = load_whole_dataset(os.path.join(
FLAGS.dataset_dir, "train.tfrecords"),
get_images=True,
get_zcas=False,
get_labels=True,
get_emb=False,
ds_size=73257)
train_X = svhn_dict.pop("image")
train_Y = svhn_dict.pop("label")
svhn_dict = load_whole_dataset(os.path.join(
FLAGS.dataset_dir, "test.tfrecords"),
get_images=True,
get_zcas=False,
get_labels=True,
get_emb=False,
ds_size=26032)
test_X = svhn_dict.pop("image")
test_Y = svhn_dict.pop("label")
ds_dict["test"] = tf.data.Dataset.from_tensor_slices({
"X":
test_X,
"Y":
test_Y
})
size_dict["test"] = test_X.shape[0]
if FLAGS.dataset == "cifar10" or FLAGS.dataset == "svhn":
#Form labeled and unlabeled datasets
perm = np.random.RandomState(
seed=FLAGS.label_seed).permutation(
np.arange(train_X.shape[0]))
train_X_l = train_X[perm[0:FLAGS.num_labeled], :]
train_Y_l = train_Y[perm[0:FLAGS.num_labeled], :]
train_X_ul = train_X[perm[FLAGS.num_labeled:], :]
train_Y_ul = train_Y[perm[FLAGS.num_labeled:], :]
del train_X
init_conf_vals = gutils.init_matrix(
np.argmax(train_Y, axis=1), perm[0:FLAGS.num_labeled])
CACHE_F = tf.get_variable(name="cache_f",
initializer=tf.constant(
init_conf_vals,
dtype=tf.float32),
trainable=True)
size_dict["X_shape"] = list(train_X_l[0, :].shape)
size_dict["Y_shape"] = list(init_conf_vals[0, :].shape)
print(train_Y.shape)
#Create variables for initial labels
PRIOR_Y_l = tf.Variable(
init_conf_vals[perm[0:FLAGS.num_labeled], :],
name="prior_yl")
#Update dicts
ds_dict["labeled"] = tf.data.Dataset.from_tensor_slices({
"X":
train_X_l,
"Y":
train_Y_l,
"ID":
np.reshape(perm[0:FLAGS.num_labeled], [-1, 1])
})
ds_dict["unlabeled"] = tf.data.Dataset.from_tensor_slices({
"X":
train_X_ul,
"Y":
train_Y_ul,
"ID":
np.reshape(perm[FLAGS.num_labeled:], [-1, 1])
})
size_dict["unlabeled"] = train_X_ul.shape[0]
print("Reading dataset...Done!")
#Load affmat
print("Loading Affmat...")
K, AFF = load_whole_affmat(
FLAGS.affmat_path,
ds_size=50000 if FLAGS.dataset == "cifar10" else 73257)
K = K[:, 0:FLAGS.affmat_k, :]
AFF = AFF[:, 0:FLAGS.affmat_k]
K = tf.constant(K, dtype=tf.int64)
AFF = tf.exp(-np.square(AFF) /
(2 * FLAGS.affmat_sigma * FLAGS.affmat_sigma))
AFF = tf.get_variable(name="Affinity_matrix",
initializer=tf.cast(
AFF, dtype=tf.float32))
print("Loading Affmat...Done!")
else:
#Extract info for toy_dict
toy_dict = toy.getTFDataset(FLAGS.dataset,
FLAGS.num_labeled,
FLAGS.label_seed)
df_x = toy_dict.pop(
"df_x"
) #Used to create Affinity Mat and infer num_unlabeled.
df_y_l = toy_dict.pop("df_y_l") #Used to create var
df_y = toy_dict.pop("df_y") #Used to create var
init_conf_vals = toy_dict.pop(
"INIT") #Used to infer Y shape
ds_dict = {
"labeled": toy_dict["labeled"],
"unlabeled": toy_dict["unlabeled"]
}
#Create variable for initial labels and F cache
PRIOR_Y_l = tf.Variable(df_y_l, name="prior_yl")
CACHE_F = tf.get_variable(name="cache_f",
initializer=init_conf_vals,
trainable=True)
#Update dicts
size_dict["X_shape"] = list(df_x[0, :].shape)
size_dict["Y_shape"] = list(init_conf_vals[0, :].shape)
size_dict["unlabeled"] = df_x.shape[0] - FLAGS.num_labeled
print("Reading dataset...Done!")
#Load affmat
print("Loading Affmat...")
W= AffMatGenerator(dist_func="gaussian",mask_func="knn",k=FLAGS.affmat_k,sigma=FLAGS.affmat_sigma).\
generateAffMat(df_x)
#Convert K to [:,0:K,2] array, i.e. 2D array of [i,j] pairs
K = np.zeros((W.shape[0], FLAGS.affmat_k, 2),
dtype=np.int64)
for i in np.arange(W.shape[0]):
K[i, :, 0] = i
K[:, :, 1] = np.argsort(-W, axis=1)[:, :FLAGS.affmat_k]
#Create corresponding [:,0:K] tensor containing the distances
AFF = np.zeros((W.shape[0], FLAGS.affmat_k))
for i in np.arange(W.shape[0]):
for j in np.arange(FLAGS.affmat_k):
AFF[i, j] = W[K[i, j, 0], K[i, j, 1]]
assert (AFF[i, j] > 0)
AFF = tf.get_variable(name="Affinity_matrix",
initializer=tf.cast(
AFF, dtype=tf.float32))
print("Loading Affmat...Done!")
#Create D variable
D = tf.get_variable(name="D",dtype=tf.float32,
initializer=tf.math.reduce_sum(
tf.get_variable("Affinity_matrix"),axis=1)\
)
size_dict[
"train"] = size_dict["labeled"] + size_dict["unlabeled"]
#Make the datasets shuffle,repeat,batch
ds_dict["train_eval"] = ds_dict["labeled"].concatenate(
ds_dict["unlabeled"]).batch(FLAGS.ul_batch_size)
ds_dict["unlabeled_eval"] = ds_dict["unlabeled"].batch(
FLAGS.batch_size)
ds_dict["labeled_eval"] = ds_dict["labeled"].batch(
FLAGS.ul_batch_size)
ds_dict["unlabeled"] = ds_dict["unlabeled"].shuffle(
1000).repeat().batch(FLAGS.ul_batch_size)
ds_dict["labeled"] = ds_dict["labeled"].shuffle(
1000).repeat().batch(FLAGS.batch_size)
if "test" in ds_dict.keys():
ds_dict["test_eval"] = ds_dict["test"].batch(
FLAGS.batch_size)
ds_dict["test"] = ds_dict["test"].shuffle(
size_dict["test"]).repeat().batch(FLAGS.ul_batch_size)
#Create variable for initial unlabeled
TRAIN_Y_UL = tf.Variable(np.zeros(
(size_dict["unlabeled"], size_dict["Y_shape"][0])),
name="y_ul")
for key, value in ds_dict.items():
it_dict[key] = value.make_initializable_iterator()
nxt_dict[key] = it_dict[key].get_next()
with tf.device("/gpu:0"):
with tf.variable_scope("Vars", reuse=tf.AUTO_REUSE):
#Define config
tfconfig = tf.ConfigProto(allow_soft_placement=True)
tfconfig.gpu_options.per_process_gpu_memory_fraction = 0.7
with tf.Session(config=tfconfig) as sess:
print("Setting placeholders...")
#PLACEHOLDERS
LGC_ALPHA = tf.placeholder_with_default(
tf.cast(0.00001, tf.float32),
shape=[],
name="learning_rate")
lr = tf.placeholder_with_default(tf.cast(
FLAGS.learning_rate, tf.float32),
shape=[],
name="learning_rate")
mom = tf.placeholder_with_default(tf.cast(
FLAGS.mom1, tf.float32),
shape=[],
name="momentum")
X_l = tf.placeholder(dtype=tf.float32,
shape=[None] + size_dict["X_shape"],
name="placeholder/X_l")
Y_l = tf.placeholder(dtype=tf.float32,
shape=[None] + size_dict["Y_shape"],
name="placeholder/Y_l")
X_u = tf.placeholder(dtype=tf.float32,
shape=[None] + size_dict["X_shape"],
name="placeholder/X_ul")
Y_u = tf.placeholder(dtype=tf.float32,
shape=[None] + size_dict["Y_shape"],
name="placeholder/Y_ul")
ID_l = tf.placeholder(dtype=tf.int64,
shape=[None],
name="placeholder/ID_l")
ID_u = tf.placeholder(dtype=tf.int64,
shape=[None],
name="placeholder/ID_u")
print("Setting placeholders...Done!")
print("Setting writers...")
#Create FileWriter
if not FLAGS.log_dir:
writer_dict["train"] = None
writer_dict["labeled"] = None
writer_dict["unlabeled"] = None
writer_dict["test"] = None
else:
writer_dict["train"] = tf.summary.FileWriter(
FLAGS.log_dir + "/train")
writer_dict["labeled"] = tf.summary.FileWriter(
FLAGS.log_dir + "/labeled")
writer_dict["unlabeled"] = tf.summary.FileWriter(
FLAGS.log_dir + "/unlabeled")
writer_dict["test"] = tf.summary.FileWriter(
FLAGS.log_dir + "/test")
print("Setting writers...Done!")
print("Setting training graph...")
#Build training_graph
loss, train_op, cache_op, _, extra = build_training_graph(
is_training=True,
X_l=X_l,
Y_l=Y_l,
X_u=X_u,
ID_l=ID_l,
ID_u=ID_u,
K=K,
lr=lr,
mom=mom,
lgc_alpha=LGC_ALPHA)
print("Setting training graph...Done!")
print("Setting test graph...")
# Build eval graph
eval_loss, _, _, eval_logit, _ = build_training_graph(
is_training=False,
X_l=X_l,
Y_l=Y_l,
X_u=X_u,
ID_l=ID_l,
ID_u=ID_u,
K=K,
lr=lr,
mom=mom,
lgc_alpha=LGC_ALPHA)
print("Setting test graph... Done!")
print((tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)))
print((tf.get_collection(tf.GraphKeys.SAVEABLE_OBJECTS)))
#####################################################################################
mon_sess = sess
for var in tf.global_variables():
print("Initializing Variable {}: shape {}".format(
var.name, var.shape, flush=True))
mon_sess.run(var.initializer)
#print(mon_sess.run(var))
print("Initializing Variable {}: shape {}...Done!".
format(var.name, var.shape))
'''
saver = tf.train.Saver()
save_path = saver.save(sess, FLAGS.train_dir)
print("Model saved in path: %s" % save_path)
'''
for ep in range(FLAGS.num_epochs):
print("EPOCH:{}".format(ep))
#Adjust decay if necessary
if ep < FLAGS.epoch_decay_start:
feed_dict = {
lr: FLAGS.learning_rate,
mom: FLAGS.mom1,
LGC_ALPHA: FLAGS.lgc_alpha
}
print("MOMENTUM:{},lr:".format(
FLAGS.mom1, FLAGS.lgc_alpha))
else:
decayed_lr = ((FLAGS.num_epochs - ep) /
float(FLAGS.num_epochs -
FLAGS.epoch_decay_start)
) * FLAGS.learning_rate
feed_dict = {
lr: FLAGS.learning_rate,
mom: FLAGS.mom1,
LGC_ALPHA: FLAGS.lgc_alpha
}
#Initialize loss,time and iterator
start = time.time()
mon_sess.run([
it_dict["labeled"].initializer,
it_dict["unlabeled"].initializer
])
losses_dict = {}
for k in loss.keys():
losses_dict[k] = 0.0
#Run training examples
for i in range(FLAGS.num_iter_per_epoch):
nxt_l, nxt_u = mon_sess.run(
[nxt_dict["labeled"], nxt_dict["unlabeled"]])
feed_dict[X_l] = nxt_l["X"]
feed_dict[Y_l] = nxt_l["Y"]
feed_dict[ID_l] = np.reshape(nxt_l["ID"], [-1])
feed_dict[X_u] = nxt_u["X"]
#feed_dict[Y_u] = nxt_u["Y"]
feed_dict[ID_u] = np.reshape(nxt_u["ID"], [-1])
if ep < FLAGS.epoch_decay_start:
_, batch_loss = mon_sess.run(
[train_op, loss], feed_dict=feed_dict)
else:
_, _, batch_loss = mon_sess.run(
[train_op, cache_op, loss],
feed_dict=feed_dict)
for k, v in batch_loss.items():
losses_dict[k] += v
#Print elapsed time, get global step
end = time.time()
current_global_step = tf.train.get_global_step().eval(
mon_sess)
#Get mean of losses
for k, v in batch_loss.items():
losses_dict[k] /= FLAGS.num_iter_per_epoch
#Add Summary
summary = tf.Summary()
for k, v in batch_loss.items():
summary.value.add(tag=k, simple_value=v)
writer_dict["train"].add_summary(
summary, current_global_step)
print("Epoch:", ep, "; LGC loss",
losses_dict["lgc_loss"], "; LGC_sup_loss",
losses_dict["lgc_supervised_loss"],
"; LGC_unsup_loss",
losses_dict["lgc_unsupervised_loss"],
"; sup_acc", losses_dict["mean_acc"],
"; elapsed_time:", end - start)
''' EVAL Procedure '''
if (
ep + 1
) % FLAGS.eval_freq == 0 or ep + 1 == FLAGS.num_epochs:
def eval(KEY, is_writing=True):
sum_loss = 0
start = time.time()
mon_sess.run(it_dict[KEY +
"_eval"].initializer)
pred_Y = None
actual_Y = None
IDs = None
#Run eval examples
while True:
try:
nxt = mon_sess.run(nxt_dict[KEY +
"_eval"])
feed_dict[X_l] = nxt["X"]
feed_dict[Y_l] = nxt["Y"]
feed_dict[ID_l] = np.reshape(
nxt["ID"], [-1])
mean_acc, logit_l = mon_sess.run(
[
eval_loss["mean_acc"],
eval_logit
],
feed_dict=feed_dict)
sum_loss += mean_acc * nxt["X"].shape[0]
if pred_Y is None:
pred_Y = logit_l
actual_Y = nxt["Y"]
IDs = nxt["ID"]
else:
pred_Y = np.concatenate(
[pred_Y, logit_l])
actual_Y = np.concatenate(
[actual_Y, nxt["Y"]])
IDs = np.concatenate(
[IDs, nxt["ID"]])
except tf.errors.OutOfRangeError:
break
#Print elapsed time, get global step
end = time.time()
current_global_step = tf.train.get_global_step(
).eval(mon_sess)
#Add Summary
summary = tf.Summary()
summary.value.add(tag="acc",
simple_value=sum_loss /
size_dict[KEY])
if is_writing:
writer_dict[KEY].add_summary(
summary, current_global_step)
print("Eval {}: {} accuracy ".format(
KEY, sum_loss / size_dict[KEY]))
#Sort pred w.r.t ids
IDs = np.reshape(IDs, [-1]).tolist()
return (pred_Y, actual_Y, IDs)
eval("labeled")
eval("unlabeled")
#if "test" in ds_dict.keys():
# eval("test")
if not FLAGS.dataset in ["svhn", "cifar10"]:
pred_Y, actual_Y, pred_ids = eval("train")
pred_Y[pred_ids, :] = pred_Y
actual_Y[pred_ids, :] = actual_Y
pred_Y = np.argmax(mon_sess.run(CACHE_F),
axis=1)
actual_Y = np.argmax(actual_Y, axis=1)
labeledIndexes = np.zeros([pred_Y.shape[0]],
dtype=np.bool)
labeledIndexes[
pred_ids[0:FLAGS.num_labeled]] = True
if (ep + 1) == FLAGS.eval_freq:
vertex_opt = sslplot.vertexplotOpt(pred_Y,size=5,\
labeledIndexes=labeledIndexes)
sslplot.plotGraph(
df_x,
W,
vertex_opt,
online=False,
interactive=False,
title="NN pred - labeled",
plot_filename="0.png")
vertex_opt = sslplot.vertexplotOpt(pred_Y,size=5,\
labeledIndexes=np.logical_not(labeledIndexes))
sslplot.plotGraph(
df_x,
W,
vertex_opt,
online=False,
interactive=False,
title="NN pred - unlabeled",
plot_filename=str(current_global_step) +
".png")
def plot_true_classif(self,X_transformed,Y,W):
#Plot 2: True classif
if self.args["can_plot"]:
vertex_opt = plt.vertexplotOpt(Y=Y,mode="discrete",size=7)
plt.plotGraph(X_transformed,plot_dim=2,W=W, vertex_opt= vertex_opt,edge_width=1,\
interactive = False,title="True classes")
def result():
error = None
if request.method == "POST":
customersAccount = session['fidor_customer']
customerDetails = customersAccount['data'][0]
customerInformation = customerDetails['customers'][0]
tickerCode = request.form['stockSymbol']
# Refer to plot.py for graph plotting function that utilises 2 APIs -
# plotly to plot the candlestick chart with information form Alphavantage)
# exception are to ignore erros that occurs after every plotted graph
try:
plotGraph(tickerCode)
except Exception:
pass
url = "https://financialmodelingprep.com/api/company/profile/"+ tickerCode +""
payload = ""
headers = {
'cache-control': "no-cache",
'Postman-Token': "e0003f95-e8c6-4cea-8142-99336827454d"
}
response = requests.request("GET", url, data=payload, headers=headers)
# API Returns JSON with <pre> tags at the front and back
# removed the tags before formatting it as JSON
stockData = json.loads(response.text[5:-5])
# To get all relevant stock data
name = stockData[tickerCode]["companyName"]
latestStockPrices = stockData[tickerCode]["Price"]
beta = stockData[tickerCode]["Beta"]
avgVolume = stockData[tickerCode]["VolAvg"]
changePerc = stockData[tickerCode]["ChangesPerc"]
exchange = stockData[tickerCode]["exchange"]
industry = stockData[tickerCode]["industry"]
sector = stockData[tickerCode]["sector"]
website = stockData[tickerCode]["website"]
ceo = stockData[tickerCode]["CEO"]
desc = stockData[tickerCode]["description"]
# Used to change colour of card in HTML based on positive/negative changes
if "+" in changePerc:
positive = True
else:
positive = False
# Used to get News from NEWSAPI
news_url = "https://newsapi.org/v2/everything"
today = datetime.now().strftime('%Y-%m-%d')
yesterday = (datetime.now()- timedelta(days=1)).strftime('%Y-%m-%d')
news_querystring = {"q":tickerCode,"from":yesterday,"to":today,"sortBy":"popularity","apiKey":"346d2c3a1c3a4c69abf68e33624b6311"}
news_payload = ""
news_headers = {
'cache-control': "no-cache",
'Postman-Token': "07bfdeb7-256c-4b75-9672-9b5a776b42d4"
}
news_response = requests.request("GET", news_url, data=news_payload, headers=news_headers, params=news_querystring)
newsJSON = json.loads(news_response.text)
news = newsJSON['articles']
source = list()
title = list()
description = list()
date = list()
url = list()
# Appending the news data to the relevant list
try:
for x in news:
source.append(x['source']['name'])
title.append(x['title'])
description.append(x['description'])
date.append(x['publishedAt'][0:10])
url.append(x['url'])
except Exception:
pass
return render_template('equity.html', tCode=tickerCode, sName = name,sPrice = latestStockPrices,
sBeta = beta, sVolume = avgVolume, sChangeP = changePerc, sPositive = positive,
sExchange = exchange, sIndustry = industry, sSector = sector, sWebsite = website, sCEO = ceo,
sDesc = desc, fFirstName = customerInformation["first_name"], fLastName = customerInformation["last_name"],
eBalance = (customerDetails['balance']/100), eNewsSource = source, eNewsTitle = title, eNewsDesc = description,
eNewsDate = date, eNewsURL = url)
