def init_visualizer():
vis = visualizer.Visualizer(500, 500)
lst = [i for i in range(100)]
random.shuffle(lst)
return lst, vis
def __init__(self, dirname, graph_name):
self.HEIGHT = 600
self.WIDTH = 800
self.dirname = dirname
self.graph_name = graph_name
# Init window
Gtk.Window.__init__(self, title="Disk data visualization")
self.set_default_size(self.WIDTH, self.HEIGHT)
# Header Bar
self.hb = Gtk.HeaderBar()
self.hb.set_show_close_button(True)
self.hb.props.title = "Disk data visualization"
self.set_titlebar(self.hb)
# Scroll
self.scroll = Gtk.ScrolledWindow(None, None)
# Webview
self.webview = WebKit.WebView()
self.webview.set_size_request(self.WIDTH - 50, self.HEIGHT - 80)
# Button
self.button = Gtk.Button(label="Help")
self.button.connect("clicked", self.on_button_clicked)
# Add the stuff together
self.hb.pack_end(self.button)
self.scroll.add(self.webview)
self.add(self.scroll)
# Generate and display the graph
self.vis = visualizer.Visualizer()
self.vis.create_graph(self.dirname, self.graph_name)
self.webview.open("file://localhost" + path.abspath(self.dirname) + "/" + self.graph_name+ ".svg")
def __init__(self,
movers,
domainSize,
noise,
peakThreshold=1e-2,
resolution=9,
singlePoint=True,
display=False):
self.viz = visualizer.Visualizer()
self.movers = movers
self.domainSize = domainSize
self.singlePoint = singlePoint
self.peakThreshold = peakThreshold
self.resolution = resolution
self.planeQueue = []
w = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
self.decayWeights = w / np.sum(w)
#self.decayWeights = np.array([1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0])
self.timeStep = 0
self.noise = noise
print("Decay weight sum: ", np.sum(self.decayWeights))
print("Decay weights: ", self.decayWeights)
if display:
plt.plot(range(0, len(self.decayWeights), 1), self.decayWeights,
'go')
plt.title("Decay weights")
plt.show()
def __init__(self, frameWidth, frameHeight):
self.frameWidth = frameWidth
self.frameHeight = frameHeight
self.cam.init(9, 6, 'camera_cal/calibration*.jpg')
self.cam.calibrate()
self.homographyOp.setFrameSize(frameWidth, frameHeight)
self.homographyOp.estimateRoadHomography()
self.laneLinesFinder = lf.LaneLinesFinder(frameWidth, frameHeight)
self.visualizer = visu.Visualizer(self.laneLinesFinder, self)
def __init__(self, filename):
# TODO 1 1b - nacist data z configuracniho xml souboru (nazev v parametru
# filename)
# TODO 2 0.5b - vytvorit instancni promenne (login, data, gameserver)
# login - nastavit dle hodnoty prectene z XML
# data - prazdny list, kde budou ukladana data ze serveru
# gameserver - pripojit se k XML-RPC serveru (url v XML souboru)
self.visualizer = visualizer.Visualizer()
# TODO 3 0.5p - na serveru zavolat metodu add_player s parametrem login (v instancni promenne login)
file = open(filename, "r")
feed = file.read()
root = ET.fromstring(feed)
self.login = root.find("login").text
self.data = []
self.visualizer = visualizer.Visualizer()
self.gameserver= xmlrpc.client.ServerProxy(root.find("url").text)
self.gameserver.add_player(self.login)
def __init__(self, planes, weights):
self.referencePlanes = np.array(planes)
print("Plane shape: ", self.referencePlanes.shape)
self.weights = np.array(weights)
self.viz = visualizer.Visualizer()
self.baseResolution = 9
#meshgrid used for gaussian calculations
numGrids, xlength, ylength = self.referencePlanes.shape
X = np.arange(0, xlength, 1)
Y = np.arange(0, ylength, 1)
self.X = X
self.Y = Y
self.X, self.Y = np.meshgrid(self.X, self.Y)
def __init__(self, filename):
# TODO 1 - nacist data z configuracniho xml souboru (nazev v parametru
# filename)
# TODO 2 - vytvorit instancni promenne (login, data, vizualizer,
# gameserver)
# login - naplnit daty prectenymi z XML
# data - prazny list, kde budou ukladana data ze serveru
# visualizer - instance tridy v visualizer.Visualizer
# gameserver - pripojit se k XML-RPC serveru (url v XML souboru)
# TODO 3 - na serveru zavolat metodu add_player s parametrem login
# (v instancni promenne login)
tree = ET.parse(filename)
self.login = tree.find("login").text
self.data = []
self.visualizer = visualizer.Visualizer()
self.gameserver = xmlrpclib.ServerProxy(tree.find("url").text)
self.gameserver.add_player(self.login)
def __init__(self, model, *args, **kwargs):
super(Agent, self).__init__(model=model, *args, **kwargs)
self.id = len(Agent.agents)
self.observation_space_dim = None
self.action_space_dim = None
self.episode = np.int16(-1)
self.nb_steps = np.int16(10**4)
assert os.getenv("EPISODES"), "Env variable 'EPISODES' is not set"
self.nb_episodes = int(os.getenv("EPISODES"))
self.episode_step = 0
self.step = 0
self.last_observation = None
self.last_action = None
self.callbacks = None
self.history = rl.core.History()
Agent.agents.append(self)
if self.visualize:
self.visualizer = visualizer.Visualizer(self.rlcc_nodes_num)
def run_app(img1_path,
img2_path,
harris_thr,
descriptor,
patch_size,
matching_threshold,
ransac_sample_size,
ransac_n_iterations,
ransac_tolerance,
ransac_inlier_threshold,
visualize=True,
experiment_id=None,
case_id=None):
# Prepare the results directory for the experiment
save_results = False
results_dir = None
if experiment_id:
save_results = True
results_dir = "./Results/Exp-" + experiment_id + "/"
if not os.path.exists(results_dir):
os.makedirs(results_dir)
print("Experiment: {} | Case: {}".format(experiment_id, case_id))
# Read and prepare the images
img1 = cv2.imread(img1_path)
img1_rgb = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
img1_gray = cv2.cvtColor(img1_rgb, cv2.COLOR_RGB2GRAY)
img2 = cv2.imread(img2_path)
img2_rgb = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
img2_gray = cv2.cvtColor(img2_rgb, cv2.COLOR_RGB2GRAY)
# Create the visualizer object
vis = visualizer.Visualizer(img1_rgb, img2_rgb, visualize, save_results,
results_dir, case_id)
# Create sift object (sift descriptor used only if enabled)
sift = cv2.xfeatures2d.SIFT_create(nfeatures=500)
# -------------------------------------------------------------------------
# Perform Harris Corner detection
img1_kpts, img2_kpts = utils.get_Harris_corners(img1_gray, img2_gray,
harris_thr)
vis.set_keypoints(img1_kpts, img2_kpts)
vis.draw_keypoints()
# -------------------------------------------------------------------------
# Extract descriptors
if descriptor == 'opencv_sift':
_, img1_descriptors = sift.compute(
img1_gray, utils.cvt_to_cv2KeyPoints(img1_kpts))
_, img2_descriptors = sift.compute(
img2_gray, utils.cvt_to_cv2KeyPoints(img2_kpts))
elif descriptor == 'custom_gray_intensities':
img1_descriptors = descriptors.gray_intensities(
img1_gray, img1_kpts, patch_size)
img2_descriptors = descriptors.gray_intensities(
img2_gray, img2_kpts, patch_size)
elif descriptor == 'custom_rgb_intensities':
img1_descriptors = descriptors.rgb_intensities(img1_rgb, img1_kpts,
patch_size)
img2_descriptors = descriptors.rgb_intensities(img2_rgb, img2_kpts,
patch_size)
# Normalize the descriptors
img1_descriptors = utils.normalize(img1_descriptors)
img2_descriptors = utils.normalize(img2_descriptors)
# -------------------------------------------------------------------------
# Get similarity matrices
# - High similarity = Low euc distance, High correlation
# - Common shape: [n_img1_kpts, n_img2_kpts]
euc_distance_matrix = utils.compute_euclidean_distances(
img1_descriptors, img2_descriptors)
correlation_matrix = utils.compute_correlation(img1_descriptors,
img2_descriptors)
# Matching keypoint pair indices.
matching_kpt_pair_indices = utils.get_matchings(
correlation_matrix,
similarity_type='correlation',
threshold=matching_threshold)
# Visualize matchings
vis.set_matches(matching_kpt_pair_indices)
vis.draw_matches(title="Matching pairs of keypoints")
# -------------------------------------------------------------------------
# Perform RANSAC to obtain the affine matrix
ransac_estimator = ransac.RANSAC_Estimator(ransac_sample_size,
ransac_n_iterations,
ransac_tolerance,
ransac_inlier_threshold)
affine_matrix, avg_residual, inlier_indices = ransac_estimator.estimate_affine_matrix(
img1_kpts, img2_kpts, matching_kpt_pair_indices)
metrics = {
'n-inliers': None,
'n-outliers': None,
'avg-inlier-residual': None,
'avg-inlier-euc-dist': None
}
metrics['n-inliers'] = inlier_indices.shape[0]
metrics['n-outliers'] = matching_kpt_pair_indices.shape[
0] - inlier_indices.shape[0]
metrics['avg-inlier-residual'] = avg_residual
metrics['avg-inlier-euc-dist'] = ransac.evaluate_model(
affine_matrix, img1_kpts, img2_kpts, inlier_indices)
if experiment_id:
with open(results_dir + "result.txt", 'a') as result_file:
result = "{:d},{:d},{:.2f},{:.2f}\n".format(
metrics['n-inliers'], metrics['n-outliers'],
metrics['avg-inlier-residual'], metrics['avg-inlier-euc-dist'])
result_file.write(result)
print("No. of inliers: {:.3f}".format(metrics['n-inliers']))
print("No. of outliers: {:.3f}".format(metrics['n-outliers']))
print("Avg. inlier residual (before refitting): {:.3f}".format(
metrics['avg-inlier-residual']))
print("Avg. inlier Euclidean distance (after refitting): {:.3f}".format(
metrics['avg-inlier-euc-dist']))
print("\n")
vis.set_inliers(inlier_indices)
# -------------------------------------------------------------------------
# Apply Affine transform
img2_warped = cv2.warpPerspective(
img2_rgb, affine_matrix,
(img1_gray.shape[1] + img2_gray.shape[1], img1_gray.shape[0]))
vis.draw_matches(title="Inliers (blue) and Outliers (red)")
vis.stitch_and_display(img2_warped, display_all=False)
matrix = [[1,2,5],[3,4,0],[6,7,8]]
#path, cost, explored, search_depth = puzzle_solver.solve(matrix, 'a_star', prioritized=True, heuristic=Heuristic(distance.cityblock))
path, cost, explored, search_depth = puzzle_solver.solve(matrix, 'dfs')
path_list = []
print("PATH:")
while not path.empty():
path_matrix = path.get().matrix
print(path_matrix)
path_list.append(path_matrix)
print()
print("COST:")
print(cost)
print()
print("EXPLORED:")
print([state.matrix for state in explored])
print()
print("No of turns:")
print(len(explored) - 1)
print()
print("SEARCH DEPTH:")
print(search_depth)
print()
puzzle_visualizer = visualizer.Visualizer(path_list, 140, -200, 240, 'black')
puzzle_visualizer.play()
def investigate(layerNames, layerIndexes, conditionOn, save_index=6):
vis = visul.Visualizer(2*16)
means = {}
variations = {}
ablations = {}
coord = tf.train.Coordinator()
sess = tf.Session()
to_restore = {}
with tf.variable_scope("GEN/"):
Generator = model.WaveNetModel(1,
dilations=g.options["dilations"],
filter_width=g.options["filter_width"],
residual_channels=g.options["residual_channels"],
dilation_channels=g.options["dilation_channels"],
skip_channels=g.options["skip_channels"],
quantization_channels=g.options["quantization_channels"],
use_biases=g.options["use_biases"],
scalar_input=g.options["scalar_input"],
initial_filter_width=g.options["initial_filter_width"],
global_condition_cardinality=None,
histograms=False,
add_noise=True)
variables_to_restore = {
var.name[:-2]: var for var in tf.global_variables()
if not (('state_buffer' in var.name or 'pointer' in var.name) and "GEN/" in var.name) }
saver = tf.train.Saver(variables_to_restore)
print("Restoring model")
ckpt = tf.train.get_checkpoint_state(logdir)
saver.restore(sess, ckpt.model_checkpoint_path)
print("Model {} restored".format(ckpt.model_checkpoint_path))
sampleph = tf.placeholder(tf.float32, [1,Generator.receptive_field,1])
controlph = tf.placeholder(tf.float32, [1, None, g.options["residual_channels"]])
eph = tf.placeholder(tf.float32, [1, None, g.options["residual_channels"]])
noiseph = tf.placeholder(tf.float32, [1,1,g.options["noise_dimensions"]])
encoded = ops.mu_law_encode(sampleph, g.options["quantization_channels"])
sample = tf.placeholder(tf.float32)
ablationsholder = {}
ablationsholder[layerNames[0]] = {}
ablationsholder[layerNames[0]][layerIndexes[0]] = controlph
eholder = {}
eholder[layerNames[0]] = {}
eholder[layerNames[0]][layerIndexes[0]] = eph
one_hot = Generator._one_hot(encoded)
controlled_sample = Generator._create_ablated_network(one_hot, None, ablationsholder, eholder, noise=noiseph)
c_arg_maxes = tf.nn.softmax(controlled_sample, axis=2)
next_sample = Generator._create_network(one_hot, None, noise = noiseph)
arg_maxes = tf.nn.softmax(next_sample, axis=2)
decoded = ops.mu_law_decode(sample, g.options["quantization_channels"])
#print(np.shape(arg_maxes))
# Sampling with argmax atm
#intermed = tf.sign(tf.reduce_max(arg_maxes, axis=2, keepdims=True)-arg_maxes)
#one_hot = (intermed-1)*(-1)
#fake_sample = tf.concat((tf.slice(encoded, [0,1,0], [-1,-1,-1]), appendph),1)
# Start audio
audio, sr = librosa.load(conditionOn, g.options["sample_rate"], mono=True)
# This should be previously generated part of the experiment
#start = np.random.randint(0,len(audio)-Generator.receptive_field)
#fakey = audio[start:start+Generator.receptive_field]
fakey = audio[-Generator.receptive_field:]
print(np.shape(fakey))
noise = np.random.normal(g.options["noise_mean"], g.options["noise_variance"], size=g.options["noise_dimensions"]).reshape(1,1,-1)
for name in layerNames:
means[name] = {}
ablations[name] = {}
variations[name] = {}
for i in layerIndexes:
#ablations[name][i] = get_causal_activations(Generator._get_layer_activation(name, i, one_hot, None, noise=zeros),i)
ablations[name][i] = Generator._get_layer_activation(name, i, one_hot, None, noise=noiseph)
abl = tf.reduce_mean(ablations[name][i], axis=[0,1])
means[name][i] = tf.Variable(tf.zeros(tf.shape(abl)), name="ABL/mean_"+name+str(i))
to_restore["ABL/mean_"+name+str(i)] = means[name][i]
variations[name][i] = tf.Variable(tf.zeros(tf.shape(abl)), name="ABL/var_"+name+str(i))
to_restore["ABL/var_"+name+str(i)] = variations[name][i]
print("Restoring previous statistics")
ablatesaver = tf.train.Saver(to_restore)
ablateckpt = tf.train.get_checkpoint_state(ablatelogs)
if ablateckpt is not None:
optimistic_restore(sess, ablateckpt.model_checkpoint_path, tf.get_default_graph())
print("Statistics restored")
name = layerNames[0]
i = layerIndexes[0]
limits = means[name][i] + variations[name][i]
mask = ablations[name][i] > limits
mask_ph = tf.placeholder(tf.bool)
causal_ph = tf.placeholder(tf.float32)
causal_counter = tf.cast(mask, tf.float32) + causal_ph
stillactive = tf.logical_and(mask, mask_ph)
fakey = np.reshape(fakey, [1,-1,1])
generated = sess.run(encoded, feed_dict={sampleph : fakey})
fakey = sess.run(one_hot, feed_dict={sampleph : fakey})
sl = Generator.receptive_field
length=sl*1+1
bar = progressbar.ProgressBar(maxval=length, \
widgets=[progressbar.Bar('=', '[', ']'), ' ', progressbar.Percentage()])
bar.start()
prevNote = ""
counter = 0
act = sess.run(ablations[name][i], feed_dict={one_hot : fakey, noiseph : noise})
print(np.shape(act))
causal_count = sess.run(tf.cast(tf.zeros_like(mask), tf.bool), feed_dict={ablations[name][i] : act})
for k in range(length):
act, prediction = sess.run([ablations[name][i], arg_maxes], feed_dict={one_hot : fakey, noiseph : noise})
#fakey = sess.run(fake_sample, feed_dict={encoded : fakey, appendph : prediction})
newest_sample = prediction[-1,-1,:]
newmask = sess.run(mask, feed_dict={ablations[name][i] : act})
causal_count = sess.run(causal_counter, feed_dict={causal_ph : causal_count, mask:newmask})
#print(sess.run(tf.reduce_sum(causal_count, axis=[0,1])))
sample = np.random.choice(
np.arange(g.options["quantization_channels"]), p=newest_sample)
#sample = np.argmax(newest_sample)
generated = np.append(generated, np.reshape(sample,[1,1,1]), 1)
if counter % sl == 0 and counter != 0:
decoded = sess.run(ops.mu_law_decode(generated[0,-sl:,0], g.options["quantization_channels"]))
note = vis.detectNote(decoded, g.options["sample_rate"])
amp = vis.loudness(decoded)
print("note: %s, amp %0.4f"%(note, amp))
if prevNote != note: #and amp > 1.:
#print("note: %s, amp %0.4f"%(note, amp))
prevNote = note
break
counter += 1
fakey = sess.run(one_hot, feed_dict={encoded : generated[:,-Generator.receptive_field:,:]})
bar.update(k+1)
bar.finish()
save_ctrl=np.reshape(generated,[-1])[-sl:]
decoded = sess.run(ops.mu_law_decode(save_ctrl, g.options["quantization_channels"]))
save_ctrl = np.array(decoded)
librosa.output.write_wav("Generated/Comparision/to_copy_"+str(save_index)+".wav", save_ctrl, sr, norm=True)
causal_count = causal_count / length
print(sess.run(tf.reduce_sum(causal_count, axis=[0,1])))
print(np.shape(act))
ablat = sess.run(tf.tile(tf.reshape(limits, [1,1,-1]), [1,np.shape(act)[1],1]))
print("Target == " + note)
target=note
target_freq = vis.getFreq(target)
# Get new bit of audio for the generator
#start = np.random.randint(0,len(audio)-Generator.receptive_field)
#fakey = audio[start:start+Generator.receptive_field]
fakey = audio[-Generator.receptive_field:]
fakey = np.reshape(fakey, [1,-1,1])
generated = sess.run(encoded, feed_dict={sampleph : fakey})
uncontrolled_generated = generated
fakey = sess.run(one_hot, feed_dict={sampleph : fakey})
uncontrolled = fakey
counter = 0
np.random.seed() # Set seed
for k in range(length):
c_prediction = sess.run(c_arg_maxes, feed_dict={one_hot : fakey, ablationsholder[name][i] : ablat, eholder[name][i] : causal_count, noiseph : noise})
prediction = sess.run(arg_maxes, feed_dict={one_hot : uncontrolled, noiseph : noise})
c_newest_sample = c_prediction[-1,-1,:]
newest_sample = prediction[-1,-1,:]
c_sample = np.random.choice(
np.arange(g.options["quantization_channels"]), p=c_newest_sample)
sample = np.random.choice(
np.arange(g.options["quantization_channels"]), p=newest_sample)
#sample = np.argmax(newest_sample)
generated = np.append(generated, np.reshape(c_sample,[1,1,1]), 1)
uncontrolled_generated = np.append(uncontrolled_generated, np.reshape(sample,[1,1,1]), 1)
fakey = sess.run(one_hot, feed_dict={encoded : generated[:,-Generator.receptive_field:,:]})
uncontrolled = sess.run(one_hot, feed_dict={encoded : uncontrolled_generated[:,-Generator.receptive_field:,:]})
if counter % sl == 0 and counter != 0:
decoded = sess.run(ops.mu_law_decode(generated[0,-sl:,0], g.options["quantization_channels"]))
note = vis.detectNote(decoded, g.options["sample_rate"])
note_freq =vis.getFreq(note)
tamp = vis.loudness(decoded)
print("note: %s, amp %0.4f, freq error (abs): %0.4f"%(note, tamp, np.abs(target_freq-note_freq)))
counter += 1
generated=np.reshape(generated,[-1])
decoded = sess.run(ops.mu_law_decode(generated, g.options["quantization_channels"]))
generated = np.array(decoded)
librosa.output.write_wav("Generated/Comparision/controlled_"+str(save_index)+".wav", generated, sr, norm=True)
uncontrolled_generated=np.reshape(uncontrolled_generated,[-1])
u_decoded = sess.run(ops.mu_law_decode(uncontrolled_generated, g.options["quantization_channels"]))
uncontrolled_generated = np.array(u_decoded)
librosa.output.write_wav("Generated/Comparision/uncontrolled_"+str(save_index)+".wav", uncontrolled_generated, sr, norm=True)
sess.close()
def show(datafile: str):
data = np.load(datafile)
dataList = [d for d in data.values()]
v = vis.Visualizer()
v.show(dataList, len(dataList))
def run_viz(nvm_pipe):
viz = vz.Visualizer(nvm_pipe)
viz.launch()
def consume_results(self):
rl = rabbitListener.RabbitListener(
self.channel,
visualizer.Visualizer(self.votings_names, self.chart_type),
self.conf_file)
rl.start_consuming()
from util import *
"""Controls the circulation process between visualizer, sorting algorithms and plotter."""
def _get_args():
ap = argparse.ArgumentParser(
description="Sorting algorithms visualization.")
ap.add_argument('-a',
'--algorithm',
type=str,
help="Choose algorithm",
required=True)
args = ap.parse_args()
return args.algorithm
algorithm = _get_args()
sorter = Sorter(enable_tracking=True)
sorting_functions = {
'Selection': sorter.selection_sort,
'Insertion': sorter.insertion_sort,
'Bubble': sorter.bubble_sort,
'Heap': sorter.heap_sort,
'Quick': sorter.quick_sort,
'Merge': sorter.merge_sort
}
func = sorting_functions.get(algorithm)
func(get_random_case(50, 10000))
vis = visualizer.Visualizer(sorter.track)
vis.start()
def __init__(self, mergedPlane):
self.mergedPlane = mergedPlane
self.viz = visualizer.Visualizer()
self.peakThresholdToKeep = 0.015
from turbine import Turbine
from turbine_config import TurbineConfig
import os
from os.path import join, isfile, realpath
from numpy import array
from time import time
cfg = TurbineConfig.load('test/turbine_unittest.cfg')
turbine = Turbine(cfg)
import visualizer
vis = visualizer.Visualizer(turbine.env)
import blade_coverage
import db
grid = 7
robot = turbine.robot
manip = robot.GetActiveManipulator()
robot.GetLink('Flame').Enable(False)
DB = db.DB(join(os.environ['PYTHON_DATABASE'], 'FACE'), turbine)
T = turbine.blades[3].GetTransform()
DB.T = T
psa = (1.8500000000000032, 0.53725006964517363, 0.82546707480056725)
threshold = 5e-2
t = time()
path = blade_coverage.base_grid_validation(turbine, psa, DB, grid, threshold)
print time() - t
import preprocessing as pp import classifier as cc import visualizer as vs from sklearn import datasets from sklearn.model_selection import train_test_split import numpy as np import pandas as pd import seaborn as sns from matplotlib import pyplot as plt X = datasets.load_iris() # df = pd.DataFrame(data=X.data,columns=X.feature_names) V = vs.Visualizer() V.heatmap(X.data, X.feature_names)
#!/usr/bin/env python from multiprocessing import Process import sys import visualizer visualizer.Visualizer()
def main():
global args, best_prec1
args = parser.parse_args()
if args.dataset == 'ucf101':
num_class = 101
elif args.dataset == 'hmdb51':
num_class = 51
elif args.dataset == 'kinetics':
num_class = 400
else:
raise ValueError('Unknown dataset ' + args.dataset)
'''
consensue_type = avg
base_model = resnet_101
dropout : 0.5
'''
model = TSN(num_class,
args.num_segments,
args.modality,
base_model=args.arch,
consensus_type=args.consensus_type,
dropout=args.dropout,
partial_bn=not args.no_partialbn)
#224
crop_size = model.crop_size
#256/224
scale_size = model.scale_size
# for each modiltiy is different
input_mean = model.input_mean
input_std = model.input_std
policies = model.get_optim_policies()
#这里拥有三个augmentation
#GroupMultiScaleCrop,GroupRandomHorizontalFlip
#here GropMultiScaleCrop ,is a easily method for 裁剪边用固定位置的crop并最终resize 到 224 ，采用的插值方式，为双线性插值
#GroupRandomHorizontalFlip
train_augmentation = model.get_augmentation()
print(args.gpus)
model = model.cuda()
if args.resume:
if os.path.isfile(args.resume):
print(("=> loading checkpoint '{}'".format(args.resume)))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print(("=> loaded checkpoint '{}' (epoch {})".format(
args.evaluate, checkpoint['epoch'])))
else:
print(("=> no checkpoint found at '{}'".format(args.resume)))
cudnn.benchmark = True
# Data loading code
if args.modality != 'RGBDiff':
normalize = GroupNormalize(input_mean, input_std)
else:
normalize = IdentityTransform()
if args.modality == 'RGB':
data_length = 1
elif args.modality in ['Flow', 'RGBDiff']:
data_length = 5
#解释说这里为什么要有roll，主要还是考虑到我们所训练的是对于BGR 还是RGB
train_loader = torch.utils.data.DataLoader(TSNDataSet(
"",
args.train_list,
num_segments=args.num_segments,
new_length=data_length,
modality=args.modality,
image_tmpl="im{}.jpg",
transform=torchvision.transforms.Compose([
train_augmentation,
Stack(roll=args.arch == 'BNInception'),
ToTorchFormatTensor(div=args.arch != 'BNInception'),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(TSNDataSet(
"",
args.val_list,
num_segments=args.num_segments,
new_length=data_length,
modality=args.modality,
image_tmpl="im{}.jpg",
random_shift=False,
transform=torchvision.transforms.Compose([
GroupScale(int(scale_size)),
GroupCenterCrop(crop_size),
Stack(roll=args.arch == 'BNInception'),
ToTorchFormatTensor(div=args.arch != 'BNInception'),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and optimizer
if args.loss_type == 'nll':
criterion = torch.nn.CrossEntropyLoss().cuda()
else:
raise ValueError("Unknown loss type")
#see the optim policy
for group in policies:
print(('group: {} has {} params, lr_mult: {}, decay_mult: {}'.format(
group['name'], len(group['params']), group['lr_mult'],
group['decay_mult'])))
# general the lr here is 1e-3
optimizer = torch.optim.SGD(policies,
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
#如果说这里是验证过程，如果说不是验证过程
if args.evaluate:
validate(val_loader, model, criterion, 0)
return
viz = vis.Visualizer()
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch, args.lr_steps)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, viz)
# evaluate on validation set
if (epoch + 1) % args.eval_freq == 0 or epoch == args.epochs - 1:
prec1 = validate(val_loader, model, criterion, epoch, viz=viz)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'test_crops': model.state_dict(),
'best_prec1': prec1,
}, is_best)
# This script created actions graph with two actions in this dir called actions.svg
# You can open it in browser to see if the graph generated correctly
### IMPORTANT ###
# Before running this file please create a device file loop0 using dd and losetup
# The disk can be about 30 MB in size
import sys
sys.path.append("./..")
import blivet
import visualizer
from blivet.size import Size
b = blivet.Blivet()
b.reset()
loop = b.devicetree.getDeviceByName("loop0")
b.destroyDevice(loop)
v = visualizer.Visualizer(blivet=b, palletePath="../assets/pallete.xml")
v.create_actions_graph(".", "actions")
def visualize(evaluation_result):
phrases = evaluation_result.get("phrases", None)
print(phrases[0].__dict__["op_type"])
tex = evaluation_result.get("source_tex_file", None)
v = visualizer.Visualizer(phrases, tex)
import preprocessing as pp
import classifier as cc
import visualizer as vs
from sklearn import datasets
from sklearn.model_selection import train_test_split
import numpy as np
import pandas as pd
cols = [i for i in range(0,32)]
df = pd.read_csv('breast_cancer.csv',index_col=32).drop("id",axis=1).drop("diagnosis",axis=1)
cols = df.columns
for i in df.columns:
if "radius_mean" not in i and "texture_mean" not in i:
df = df.drop(i,axis=1)
vs.Visualizer().boxplot(df.values,df.columns)
vs.Visualizer().violinplot(df.values,df.columns)
vs.Visualizer().pairplot(df.values,df.columns)
vs.Visualizer().histogram(df.values,df.columns)
numEventTypes = len(eventTypeDict)
eventTypeList = [None] * numEventTypes
assert (numEventTypes > 0), "No event types detected (Assertion)...\n"
for i in range(0, numEventTypes):
eventTypeList[i] = eventTypeDict[i]
# Initialize event class
evn = event.Event(sys.argv[1])
evn.setEventType(eventTypeList)
# Initialize outlier class
otl = outlier.Outlier(sys.argv[1])
# Initialize visualizer class
maxDepth = int(config['Visualizer']['MaxFunDepth'])
viz = visualizer.Visualizer(sys.argv[1])
# Reset visualization server
viz.sendReset()
# In nonstreaming mode send function map and event type to the visualization server
viz.sendEventType(eventTypeList, 0)
funMap = prs.getFunMap()
viz.sendFunMap(list(funMap.values()), 0)
else:
# Initialize event object
evn = event.Event(sys.argv[1])
# Initialize outlier object
otl = outlier.Outlier(sys.argv[1])
def __init__(self, *args):
BaseHTTPServer.HTTPServer.__init__(self, *args)
self.running = True
self.visualizer = visualizer.Visualizer()
import visualizer
vis = visualizer.Visualizer(win_height=700,
win_width=1000,
line_width=5,
space=1.5)
vis.render('elijah')
def itrgenerate(self, x, l):
if l % 2 == 0:
y = (1 + math.sin(x / math.pi)) * 0.5
else:
y = (1 + math.cos(x / math.pi)) * 0.5
y += self.noise(x)
return y
def generate(self, x):
arr = [0 for _ in xrange(self.num)]
for l in xrange(self.num):
arr[l] = self.itrgenerate(x, l)
return arr
def next(self):
x = self.i
self.i += 1
return self.generate(x)
if __name__ == '__main__':
try:
vis = plt.Visualizer()
gen = SimpleGenerator()
for y in gen:
print("{}".format(y))
vis.append(y)
time.sleep(0.5)
except Exception as e:
print(str(e))
import tkinter as tk
import visualizer
if __name__ == '__main__':
root = tk.Tk()
path = "/Users/Roger/Projects/bike-computer/data/"
vis = visualizer.Visualizer(root, path)
#root.attributes('-fullscreen',True)
root.overrideredirect(True)
#root.after(1, dbg.update_display)
root.mainloop()
prepro = Preprocessing()
prepro.handleMissing(dataset)
x = dataset.drop(['price','cut','color','clarity'],axis = 1)
y = dataset['price']
x = prepro.scale(x)
encode_col = dataset[['cut','color','clarity']]
encode_col = prepro.encode(encode_col)
x = np.concatenate((x,encode_col),axis=1)
X_train, X_test, y_train, y_test = train_test_split(x, y,random_state=0,test_size=0.33)
vis.Visualizer().scatterplot(X_test[:,0],y_test.iloc[:])
# Linear Regression
regressor = reg.Regressor(type=reg.LINEAR_REGRESSION)
regressor.fit(X_train, y_train)
print("******************Linear Regression******************")
print(regressor.score(X_test,y_test))
#vis.Visualizer().scatterplot(X_test[:,0],y_test.iloc[:],regressor)
print("*************************************************")
# polynomial Regression
params = dict(degree = 5)
regressor = reg.Regressor(type=reg.POLY_REGRESSION, **params)
regressor.fit(X_train, y_train)
