def draw(name, p, clf, X, y, step, ):
stepx = step
stepy = step
x_min, y_min = np.amin(X, 0)
x_max, y_max = np.amax(X, 0)
x_min -= stepx
x_max += stepx
y_min -= stepy
y_max += stepy
xx, yy = np.meshgrid(np.arange(x_min, x_max, stepx),
np.arange(y_min, y_max, stepy))
mesh_dots = np.c_[xx.ravel(), yy.ravel()]
zz = np.apply_along_axis(lambda t: clf.predict(t), 1, mesh_dots)
zz = np.array(zz).reshape(xx.shape)
plt.figure(figsize=(10, 10))
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
x0, y0 = X[y == -1].T
x1, y1 = X[y == 1].T
plt.pcolormesh(xx, yy, zz, cmap=ListedColormap(['#FFAAAA', '#AAAAFF']))
plt.scatter(x0, y0, color='red', s=100)
plt.scatter(x1, y1, color='blue', s=100)
sup_ind = clf.get_non_bound_indices()
X_sup = X[sup_ind]
x_sup, y_sup = X_sup.T
plt.scatter(x_sup, y_sup, color='white', marker='x', s=60)
plt.suptitle(p)
plt.savefig(name + '_' + p['name'] + '.png')
plt.show()
def build_graphs(partner_info):
# type: (DataFrame) -> Figure
import matplotlib.pyplot as plt
fig = plt.figure()
ax1 = fig.add_subplot(2, 2, 1)
ax1.hist(np.random.randn(100), bins=20, alpha=0.3)
ax2 = fig.add_subplot(2, 2, 2)
ax2.scatter(np.arange(30), np.arange(30) + 3 * np.random.randn(30))
fig.add_subplot(2, 2, 3)
return fig
def isodose_display(self):
"""
Display isodoses on the DICOM Image.
"""
slider_id = self.slider.value()
curr_slice_uid = self.patient_dict_container.get("dict_uid")[slider_id]
z = self.patient_dict_container.dataset[
slider_id].ImagePositionPatient[2]
dataset_rtdose = self.patient_dict_container.dataset['rtdose']
grid = get_dose_grid(dataset_rtdose, float(z))
if not (grid == []):
x, y = np.meshgrid(np.arange(grid.shape[1]),
np.arange(grid.shape[0]))
# Instantiate the isodose generator for this slice
isodosegen = cntr.Cntr(x, y, grid)
# sort selected_doses in ascending order so that the high dose isodose washes
# paint over the lower dose isodose washes
for sd in sorted(
self.patient_dict_container.get("selected_doses")):
dose_level = sd * self.patient_dict_container.get("rx_dose_in_cgray") / \
(dataset_rtdose.DoseGridScaling * 10000)
contours = isodosegen.trace(dose_level)
contours = contours[:len(contours) // 2]
polygons = self.calc_dose_polygon(
self.patient_dict_container.get("dose_pixluts")
[curr_slice_uid], contours)
brush_color = self.iso_color[sd]
with open(resource_path('src/data/line&fill_configuration'),
'r') as stream:
elements = stream.readlines()
if len(elements) > 0:
iso_line = int(elements[2].replace('\n', ''))
iso_opacity = int(elements[3].replace('\n', ''))
line_width = float(elements[4].replace('\n', ''))
else:
iso_line = 2
iso_opacity = 5
line_width = 2.0
stream.close()
iso_opacity = int((iso_opacity / 100) * 255)
brush_color.setAlpha(iso_opacity)
pen_color = QtGui.QColor(brush_color.red(),
brush_color.green(),
brush_color.blue())
pen = self.get_qpen(pen_color, iso_line, line_width)
for i in range(len(polygons)):
self.scene.addPolygon(polygons[i], pen,
QtGui.QBrush(brush_color))
def fft():
from pandas import np
start = time.time()
np.fft.fft(np.exp(2j * np.pi * np.arange(10000000) / 8))
end = time.time()
t = end - start
print(f'fft time: {t} !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
def download_graphs_from_all(path_here, path_on_server, name_server,
folder_name):
number_folder = 35
what_to_copy = ["graph.png", "graph1.png", "graph2.png", "movie.mp4"]
folders = np.arange(0, number_folder + 1)
for el in folders:
logging.debug("Analysing folder " + str(el))
for file in what_to_copy:
remote_path = path_on_server + folder_name + "/" + str(
el) + "/" + file
bashCommand = "scp " + name_server + ":" + remote_path + " ."
directory = path_here + folder_name
try:
os.stat(directory)
except:
os.mkdir(directory)
directory = path_here + folder_name + "/" + str(el)
try:
os.stat(directory)
except:
os.mkdir(directory)
process = subprocess.Popen(bashCommand.split(),
stdout=subprocess.PIPE,
cwd=directory)
output, error = process.communicate()
logging.debug("Copied " + str(file))
def gen_unique_colors(num_colors):
# https://stackoverflow.com/questions/470690/how-to-automatically-generate-n-distinct-colors
# Response by Uri Cohen:
colors = []
for i in np.arange(0.0, 360.0, 360.0 / num_colors):
hue = i / 360.0
lightness = (50 + np.random.rand() * 10) / 100.0
saturation = (90 + np.random.rand() * 10) / 100.0
colors.append(colorsys.hls_to_rgb(hue, lightness, saturation))
return colors
def print_graph_msd_total(self, total_distance, std_distances,
path_where_to_save):
x = np.arange(len(names))
plt.figure(figsize=(12, 6))
sns.set_style("darkgrid")
plt.errorbar(x, total_distance, std_distances, elinewidth=0.5)
plt.xlabel("Generation")
plt.ylabel("msd")
# plt.show()
plt.savefig(path_where_to_save + "/msds.png", dpi=500)
plt.close()
logging.debug("msds saved!")
def __init__(
self,
n_people,
reco_seed=DEFAULT_RECO_SEED,
muta_seed=DEFAULT_MUTA_SEED,
fake_seed=DEFAULT_FAKE_SEED):
"""Initialize with the number of people to put in the base records.
Provodes variables for random seeds to be passed to,
1) the random instance used to choose columns in this class
2) the random instance used in the mutator module
3) the random instance used in the faker module
"""
# initialize mutator class
self.muta = mutator.Mutator(seed=muta_seed)
# initialize faker
self.fake = Faker()
self.fake.seed(fake_seed)
# initialize local random
self.random = random.Random()
self.random.seed(reco_seed)
# initialize empty DataFrame
df_base = pandas.DataFrame(
np.empty((n_people, len(COLS))) * np.nan,
columns=COLS)
# add unique person ID
df_base['id'] = np.arange(n_people)
# generate fake data
for i in range(n_people):
df_base.loc[i, 'first_name'] = self.fake.first_name()
df_base.loc[i, 'last_name'] = self.fake.last_name()
df_base.loc[i, 'zipcode'] = self.fake.zipcode()
self.n_people = n_people
self.df_base = df_base
# initialize index trackers
self.indx_min = self.df_base.index.min()
self.indx_max = self.df_base.index.max()
# initialize mutation history tracker
self.history = defaultdict(list)
def detect_surface(profile):
"""Automatic detection of surface (begin of snowpack).
:param profile: The profile to detect surface in.
:return: Distance where surface was detected.
:rtype: float
"""
# Cut off ca. 1 mm
distance = profile.samples.distance.values[250:]
force = profile.samples.force.values[250:]
force = downsample(force, 20)
distance = downsample(distance, 20)
force = smooth(force, 242)
y_grad = np.gradient(force)
y_grad = downsample(y_grad, 3)
x_grad = downsample(distance, 3)
max_force = np.amax(force)
try:
for i in np.arange(100, x_grad.size):
std = np.std(y_grad[:i - 1])
mean = np.mean(y_grad[:i - 1])
if y_grad[i] >= 5 * std + mean:
surface = x_grad[i]
break
if i == x_grad.size - 1:
surface = max_force
log.info('Detected surface at {:.3f} mm in profile {}'.format(
surface, profile))
return surface
except ValueError:
log.warning('Failed to detect surface')
return max_force
plt.figure(figsize=(5, 5))
image = image[0] if image.shape[-1] is 3 else image[0, ..., 0]
cmap = None if image.shape[-1] is 3 else 'gray'
plt.imshow(image, cmap=cmap, interpolation='none')
for idx, jdx in enumerate(data_generator.graph):
if jdx > -1:
x1 = keypoints[0, idx, 0]
x2 = keypoints[0, jdx, 0]
if (0 <= x1 <= IMAGE_SIZE[0]) and (0 <= x2 <= IMAGE_SIZE[0]):
plt.plot(
[keypoints[0, idx, 0], keypoints[0, jdx, 0]],
[keypoints[0, idx, 1], keypoints[0, jdx, 1]],
'r-'
)
plt.scatter(keypoints[0, :, 0], keypoints[0, :, 1], c=np.arange(data_generator.keypoints_shape[0]), s=50, cmap=plt.cm.hsv, zorder=3)
plt.show()
# Augmentation
augmenter = []
augmenter.append(FlipAxis(data_generator, axis=0)) # flip image up-down
augmenter.append(FlipAxis(data_generator, axis=1)) # flip image left-right
sometimes = []
sometimes.append(iaa.Affine(scale={"x": (0.95, 1.05), "y": (0.95, 1.05)},
translate_percent={'x': (-0.05, 0.05), 'y': (-0.05, 0.05)},
shear=(-8, 8),
order=ia.ALL,
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %I:%M:%S %p',
level=logging.DEBUG)
# first_path = "/Volumes/TheMaze/TuringLearning/february/15feb/Experiment-plusplusGeolife/"
first_path = "/Volumes/TheMaze/TuringLearning/february/snow/Experiment-plusplus/"
# read all the trajectories for the distance to the real point
logging.debug("Checking the distances...")
real_distances, real_distances_bearing = analise_distances(
first_path, "0/", True)
# 0 np.max(array), 1 np.min(array), 2 np.mean(array), 3 np.std(array), 4 np.median(array)
# single graphs
trajectories = len(real_distances[0].keys())
num = np.arange(0, trajectories)
real_total = []
number_tra = []
for tra in range(trajectories):
x = []
x = np.arange(0, len(real_distances))
median = []
for el in real_distances:
median.append(np.median(np.array(el[tra][1])))
median_bearing = []
for el in real_distances_bearing:
median_bearing.append(np.median(np.array(el[tra][1])))
total_sum_median = []
for i in range(len(median)):
# dpi参数指定绘图对象的分辨率，即每英寸多少个像素，缺省值为80 1英寸等于2.5cm,A4纸是 21*30cm的纸张 # facecolor:背景颜色 # edgecolor:边框颜色 # frameon:是否显示边框 # figure = plt.figure(num='gg', figsize=(5, 3), dpi=None, facecolor='red', edgecolor=None, frameon=True) # plt.show() # 创建单个子图 # nrows:subplot的行数 # ncols:subplot的列数 # sharex：所有subplot应该使用相同的X轴刻度(调节xlim将会影响所有的subplot) # sharex：所有subplot应该使用相同的Y轴刻度(调节ylim将会影响所有的subplot) # subpolt_kw:用于创建各subplot的关键字字典 # **fig_kw 创建figure时的其他关键字 # plt.subplot(nrows, ncols, sharex, sharey, subplot_kw, **fig_kw) x = np.arange(0, 100) # 第一行左图 #作图1 plt.subplot(221) plt.plot(x, x) #作图2 plt.subplot(222) plt.plot(x, -x) #作图3 plt.subplot(223) plt.plot(x, x**2) plt.grid(color='r', linestyle='--', linewidth=1, alpha=0.3) #作图4 plt.subplot(224) plt.plot(x, np.log(x)) plt.show()
import matplotlib.pyplot as plt
from pandas import np
fig = plt.figure(figsize=(20, 8), dpi=80)
x = np.arange(2, 26, 2)
# 数据在x轴的位置，是一个可以迭代的对象
y = [15, 13, 14, 5, 17, 20, 25, 26, 26, 17, 22, 1]
# 数据在y轴的位置，是一个可以迭代的对象
# 绘图
plt.plot(x, y)
# 绘制x轴的刻度
plt.xticks(range(2, 25))
# 保存
plt.savefig("./t1.png")
if __name__ == '__main__':
print(1)
def gbc_overfitting(date_file, X_train, y_train, X_test, y_test):
n_gb = []
score_gb = []
time_gb = []
n_gbes = []
score_gbes = []
time_gbes = []
n_estimators = 100
# We specify that if the scores don't improve by atleast 0.01 for the last
# 10 stages, stop fitting additional stages
gbes = GradientBoostingClassifier(n_estimators=n_estimators,
validation_fraction=0.2,
n_iter_no_change=10,
tol=0.01,
random_state=0)
gb = GradientBoostingClassifier(n_estimators=n_estimators, random_state=0)
start = time.time()
gb.fit(X_train, y_train)
time_gb.append(time.time() - start)
start = time.time()
gbes.fit(X_train, y_train)
time_gbes.append(time.time() - start)
score_gb.append(gb.score(X_test, y_test))
score_gbes.append(gbes.score(X_test, y_test))
n_gb.append(gb.n_estimators_)
n_gbes.append(gbes.n_estimators_)
bar_width = 0.2
n = 1
index = np.arange(0, n * bar_width, bar_width) * 2.5
index = index[0:n]
plt.figure(figsize=(9, 5))
bar1 = plt.bar(index,
score_gb,
bar_width,
label='Without early stopping',
color='crimson')
bar2 = plt.bar(index + bar_width,
score_gbes,
bar_width,
label='With early stopping',
color='coral')
plt.xticks(index + bar_width, date_file)
plt.yticks(np.arange(0, 1.3, 0.1))
def autolabel(rects, n_estimators):
"""
Attach a text label above each bar displaying n_estimators of each model
"""
for i, rect in enumerate(rects):
plt.text(rect.get_x() + rect.get_width() / 2.,
1.05 * rect.get_height(),
'n_est=%d' % n_estimators[i],
ha='center',
va='bottom')
autolabel(bar1, n_gb)
autolabel(bar2, n_gbes)
plt.ylim([0, 1.3])
plt.legend(loc='best')
plt.grid(True)
plt.xlabel('Datasets')
plt.ylabel('Test score')
plt.show()
random_state=1)
model = LinearRegression()
model.fit(x_train, y_train)
print(model.coef_, model.intercept_)
order = y_test.argsort(axis=0)
y_test = y_test.values[order]
x_test = x_test.values[order, :]
y_test_pred = model.predict(x_test)
mse = pd.np.mean((y_test_pred - pd.np.array(y_test))**2)
rmse = pd.np.sqrt(mse)
mse_sys = mean_squared_error(y_test, y_test_pred)
print('MSE= ', mse, end=' ')
print('MSE(System Function) = ', mse_sys, end=' ')
print(mean_absolute_error(y_test, y_test_pred))
error = y_test - y_test_pred
np.set_printoptions(suppress=True)
print('error = ', error)
plt.hist(error, bins=20, color='g', alpha=0.6, edgecolor='k')
plt.show()
plt.figure(facecolor='w')
t = np.arange(len(x_test))
plt.plot(t, y_test, 'r-', linewidth=2, label='真实数据')
plt.plot(t, y_test_pred, 'g-', linewidth=2, label='预测数据')
plt.legend(loc='upper left')
plt.title('线性回归预测销量', fontsize=18)
plt.grid(b=True, ls=':')
plt.show()
def run(self):
folders = how_many_fatherFolder(self.path)
folders = [s for s in folders if not re.search('txt', s)]
folders = [s for s in folders if not re.search('jpg', s)]
folders = [s for s in folders if not re.search('png', s)]
for experiemnt in folders:
logging.debug("Folder under analysis -> " + str(experiemnt))
second_path = self.path + experiemnt + "/"
res = how_many_folder(second_path)
folders = [s for s in folders if not re.search('txt', s)]
folders = [s for s in folders if not re.search('jpg', s)]
folders = [s for s in folders if not re.search('png', s)]
num_folder = len(res)
logging.debug("Folder to analise -> " + str(num_folder))
for el in res:
logging.debug("Folder under analysis -> " + str(el))
path_here = second_path + str(el) + "/"
names = []
for i in os.listdir(path_here):
if os.path.isfile(
os.path.join(path_here, i)
) and 'trajectory-generate-aSs-' in i and ".zip" in i:
names.append(i)
names = sorted_nicely(names)
pops = Populations()
# find the trajectories ID and Points
trajectories = self.read_trajectory_info(path_here +
"trajectory.zip")
for tra in trajectories:
pops.add_population(Population(tra))
# analysing the fitness
logging.debug("Analysing the fitness...")
max_agent, max_classifier = self.find_max_values_fitness(
path_here)
agent_generations_info, classifier_generations_info = self.read_fitness(
path_here, max_agent, max_classifier)
x = np.arange(len(agent_generations_info))
y_agent = []
std_agent = []
for element in agent_generations_info:
y_agent.append(element.mean)
std_agent.append(element.std)
y_classifier = []
std_classifier = []
for element in classifier_generations_info:
y_classifier.append(element.mean)
std_classifier.append(element.std)
# print fitnes
self.print_fitnes(x, y_agent, std_agent, y_classifier,
std_classifier, path_here)
total_distances = []
total_distances_msd = []
std_distances = []
last_generations_values = []
logging.debug("Analysing Trajectories...")
for i in tqdm.tqdm(range(len(names))):
name = names[i]
# obtain info from the file
individuals = self.read_info(path_here + name)
if i == len(names) - 1:
for ind in individuals:
for el in ind.array:
last_generations_values.append(el)
msds = []
for ind in individuals:
msds.append(ind.MSD)
total_distances.append(np.mean(np.array(msds)))
std_distances.append(np.std(np.array(msds)))
# store the msd per trajectory
distance_per_trajectories = {}
for j in range(number_of_trajectories):
distances = []
for indiv in individuals:
if indiv.trajectoryID == pops.get_population(
j).tra.trajectoryID:
distances.append(indiv.MSD)
array = np.array(distances)
MSD = (np.sum(array)) / len(array)
distance_per_trajectories.update({j: MSD})
total_distances_msd.append(distance_per_trajectories)
# print graph msd per trajectory
self.print_graph_msd_per_trajectory(total_distances_msd,
path_here)
# print graph total msd
self.print_graph_msd_total(total_distance, std_distances,
path_here)
# save the last value
array = np.array(last_generations_values)
MSD = (np.sum(array)) / len(array)
with open(path_here + "/MSD.txt", "w") as text_file:
text_file.write(str(MSD))
# lng_last.append(el[1])
# real_bearing = computeBearing(lat_last[len(lat_last) -1], lng_last[len(lat_last) -1], lat_real[0], lng_real[0])
#
# distances = []
# # compute distance
# for i in range(len(lat_generated)):
# # compute the distances
# bearing = computeBearing(lat_last[len(lat_last) -1], lng_last[len(lat_last) -1], lat_generated[i], lng_generated[i])
# distances.append(fabs(bearing - real_bearing))
#
# array = np.array(distances)
# real_distances.append((np.max(array), np.min(array), np.mean(array), np.std(array)))
x = []
x = np.arange(0, len(total_distances))
max_value = []
min = []
mean = []
std = []
for el in total_distances:
a = []
b = []
c = []
d = []
for k in el.keys():
a.append(el[k][0])
b.append(el[k][1])
c.append(el[k][2])
d.append(el[k][3])
max_value.append(np.mean(np.array(a)))
datefmt='%m/%d/%Y %I:%M:%S %p',
level=logging.DEBUG)
num = [3]
for el in num:
path = "/Volumes/TheMaze/TuringLearning/Experiment Christmas Holidays/Experiment-commalambda100/" + str(
el) + "/"
files = 0
for i in os.listdir(path):
if os.path.isfile(os.path.join(
path,
i)) and 'trajectory-generatedPoints-' in i and ".zip" in i:
files += 1
max = files
vect = np.arange(1, max + 1)
for numb in vect:
name = "trajectory-generatedPoints-" + str(numb) + "-" + str(
numb) + ".zip"
trajectories_label, json_file = reanInfo(path + name)
# center lat, center lng, zoom
lat_real = []
lng_real = []
for el in json_file[trajectories_label[0]]["real"]:
lat_real.append(el[0])
lng_real.append(el[1])
gmap = gmplot.GoogleMapPlotter(lat_real[0], lng_real[0], 20)
for el in trajectories_label:
all_real_distances = []
all_bearing_distances = []
for folder in folders:
logging.debug("Analysing folder " + str(folder))
real_path = path + "/" + str(folder) + "/"
files = 0
for i in os.listdir(real_path):
if os.path.isfile(os.path.join(
real_path,
i)) and 'trajectory-generatedPoints-' in i and ".zip" in i:
files += 1
vect = np.arange(1, files + 1)
# read all the trajectories for the distance to the real point
logging.debug("Checking the distances")
real_distances, real_distances_bearing = analise_distances(
path, folder)
x = []
median = []
std = []
x = np.arange(0, len(real_distances))
for el in real_distances:
median.append(el[2])
std.append(el[3])
all_real_distances.append((x, median, std))
# read the fitness and return it scaled 0-1
logging.debug("Checking the fitness...")
scaled_version_agent, gen_agent, scaled_version_classifier, gen_classifier, ok = analise_single_folder(
path, folder, max_agent, max_classifier)
if not ok:
problems.append((experiemnt, folder,
"Problem with number of fitness values"))
# read all the trajectories for the distance to the real point
logging.debug("Checking the distances...")
real_distances, real_distances_bearing = analise_distances(
path, folder, bigOrSmall)
x = []
x = np.arange(0, len(real_distances))
max_value = []
min_value = []
mean = []
std = []
for el in real_distances:
a = []
b = []
c = []
d = []
for k in el.keys():
a.append(el[k][0])
b.append(el[k][1])
c.append(el[k][2])
d.append(el[k][3])
max_value.append(np.mean(np.array(a)))
# and the transformation is applied on the test data for later use.
# The train data will be transformed while it is being fit.
y_test_binary = pd.DataFrame(y_test["value"].apply(getBinary))
regressorLow = XGBRegressor(gamma=0.0,
n_estimators=200,
base_score=0.5,
colsample_bytree=0.7,
learning_rate=0.2,
max_depth=5,
objective="reg:linear")
xgbModelLow = regressorLow.fit(X_train, y_train.value)
xgboost.plot_importance(xgbModelLow)
y_predicted = xgbModelLow.predict(X_test)
y_predicted_binary = [1 if yp >= 0.5 else 0 for yp in y_predicted]
print(accuracy_score(y_test_binary, y_predicted_binary))
fig = plt.figure(figsize=(8, 8))
plt.xticks(rotation='vertical')
y_pos = np.arange(len(xgbModelLow.feature_importances_))
plt.barh([i for i in range(len(xgbModelLow.feature_importances_))],
xgbModelLow.feature_importances_.tolist(),
align='center',
alpha=0.4)
plt.yticks(y_pos, X_test.columns)
plt.show()
'Virginia Beach', 'Baltimore', 'Denver', 'Detroit', 'San Antonio',
'Phoenix', 'Oklahoma City', 'Indianapolis', 'Milwaukee', 'Sacramento',
'Washington, D.C.', 'Colorado Springs', 'Honolulu', 'Nashville',
'Jacksonville', 'Louisville', 'Seattle', 'Memphis', 'Fresno', 'Boston',
'Mineappolis', 'San Jose', 'Tulsa', 'Charlotte', 'San Diego',
'Los Angeles', 'Long Beach', 'Cleveland', 'San Francisco',
'Albuquerque', 'Arlington, TX', 'Omaha', 'Wichita', 'Las Vegas'
]
grad = DataFrame({'change': change, 'city': city})
plt.figure(figsize=(3, 8))
change = grad.change[grad.change > 0]
city = grad.city[grad.change > 0]
pos = np.arange(len(change))
plt.title('1995-2005 Change in HS graduation rate')
plt.barh(pos, change)
# add the numbers to the side of each bar
for p, c, ch in zip(pos, city, change):
plt.annotate(str(ch), xy=(ch + 1, p + .5), va='center')
# cutomize ticks
ticks = plt.yticks(pos + .5, city)
xt = plt.xticks()[0]
plt.xticks(xt, [' '] * len(xt))
# minimize chartjunk
remove_border(left=False, bottom=False)
def __init__(self, pnt_file, name=None):
self._pnt_file = pathlib.Path(pnt_file)
# Load pnt file, returns header (dict) and raw samples
self._pnt_header, pnt_samples = Pnt.load(self._pnt_file)
# Get clean WGS84 coordinates (use +/- instead of N/E)
self._latitude = self.pnt_header_value(Pnt.Header.GPS_WGS84_LATITUDE)
self._longitude = self.pnt_header_value(Pnt.Header.GPS_WGS84_LONGITUDE)
north = self.pnt_header_value(Pnt.Header.GPS_WGS84_NORTH)
east = self.pnt_header_value(Pnt.Header.GPS_WGS84_EAST)
if north.upper() != 'N':
self._latitude = -self._latitude
if east.upper() != 'E':
self._longitude = -self._longitude
if abs(self._latitude) > 90:
log.warning('Latitude value {} invalid, replacing by None'.format(
self._latitude))
self._latitude = None
if abs(self._longitude) > 180:
log.warning('Longitude value {} invalid, replacing by None'.format(
self._longitude))
self._longitude = None
# Get a proper timestamp by putting pnt entries together
self._timestamp = None
year = self.pnt_header_value(Pnt.Header.TIMESTAMP_YEAR)
month = self.pnt_header_value(Pnt.Header.TIMESTAMP_MONTH)
day = self.pnt_header_value(Pnt.Header.TIMESTAMP_DAY)
hour = self.pnt_header_value(Pnt.Header.TIMESTAMP_HOUR)
minute = self.pnt_header_value(Pnt.Header.TIMESTAMP_MINUTE)
second = self.pnt_header_value(Pnt.Header.TIMESTAMP_SECOND)
try:
self._timestamp = datetime(year,
month,
day,
hour,
minute,
second,
tzinfo=pytz.UTC)
log.info(
'Timestamp of profile as reported by pnt header is {}'.format(
self.timestamp))
except ValueError:
log.warning('Unable to build timestamp from pnt header fields')
# Set name of profile (by default a entry from pnt header)
self._name = self.pnt_header_value(Pnt.Header.FILENAME)
if name:
self._name = name
# Get other important entries from header
self._samples_count = self.pnt_header_value(
Pnt.Header.SAMPLES_COUNT_FORCE)
self._spatial_resolution = self.pnt_header_value(
Pnt.Header.SAMPLES_SPATIALRES)
self._overload = self.pnt_header_value(Pnt.Header.SENSOR_OVERLOAD)
self._speed = self.pnt_header_value(Pnt.Header.SAMPLES_SPEED)
self._smp_serial = str(self.pnt_header_value(Pnt.Header.SMP_SERIAL))
self._smp_firmware = str(self.pnt_header_value(
Pnt.Header.SMP_FIRMWARE))
self._smp_length = self.pnt_header_value(Pnt.Header.SMP_LENGTH)
self._smp_tipdiameter = self.pnt_header_value(
Pnt.Header.SMP_TIPDIAMETER)
self._gps_pdop = self.pnt_header_value(Pnt.Header.GPS_PDOP)
self._gps_numsats = self.pnt_header_value(Pnt.Header.GPS_NUMSATS)
self._amplifier_range = self.pnt_header_value(
Pnt.Header.AMPLIFIER_RANGE)
self._amplifier_serial = self.pnt_header_value(
Pnt.Header.AMPLIFIER_SERIAL)
self._sensor_serial = self.pnt_header_value(Pnt.Header.SENSOR_SERIAL)
self._sensor_sensivity = self.pnt_header_value(
Pnt.Header.SENSOR_SENSITIVITIY)
# Create a pandas dataframe with distance and force
distance_arr = np.arange(
0, self._samples_count) * self._spatial_resolution
factor = self.pnt_header_value(Pnt.Header.SAMPLES_CONVFACTOR_FORCE)
force_arr = np.asarray(pnt_samples) * factor
stacked = np.column_stack([distance_arr, force_arr])
self._samples = pd.DataFrame(stacked, columns=('distance', 'force'))
self._ini = configparser.ConfigParser()
# Look out for corresponding ini file
self._ini_file = self._pnt_file.with_suffix('.ini')
if self._ini_file.exists():
log.info('Reading ini file {} for {}'.format(self._ini_file, self))
self._ini.read(self._ini_file)
# Ensure a section called 'markers' does exist
if not self._ini.has_section('markers'):
self._ini.add_section('markers')
# Check for invalid values (non floats) in 'markers' section
for k, v in self._ini.items('markers'):
try:
float(v)
log.info('Marker: {}={}'.format(k, v))
except ValueError:
log.warning(
'Ignoring value {} for marker {}, not float value'.format(
repr(v), repr(k)))
self._ini.remove_option('markers', k)
import matplotlib.pyplot as plt
import seaborn as sns
from pandas import np
sns.set_style("whitegrid")
plt.plot(np.arange(10))
plt.show()
def plot_dvh(self):
"""
:return: DVH plot using Matplotlib library.
"""
# Initialisation of the plots
fig, ax = plt.subplots()
fig.subplots_adjust(0.1, 0.15, 1, 1)
# Maximum value for x axis
max_xlim = 0
# Plot for all the ROIs selected in the left column of the window
for roi in self.selected_rois:
dvh = self.raw_dvh[int(roi)]
# Plot only the ROIs whose volume is non equal to 0
if dvh.volume != 0:
# Bincenters, obtained from the dvh object, give the x axis values
# (Doses originally in Gy unit)
bincenters = self.dvh_x_y[roi]['bincenters']
#print(self.dvh_x_y[roi])
# Counts, obtained from the dvh object, give the y axis values
# (values between 0 and dvh.volume)
counts = self.dvh_x_y[roi]['counts']
# Color of the line is the same as the color shown in the left column of the window
color = self.patient_dict_container.get("roi_color_dict")[roi]
color_R = color.red() / 255
color_G = color.green() / 255
color_B = color.blue() / 255
plt.plot(100 * bincenters,
100 * counts / dvh.volume,
label=dvh.name,
color=[color_R, color_G, color_B])
# Update the maximum value for x axis (usually different between ROIs)
if (100 * bincenters[-1]) > max_xlim:
max_xlim = 100 * bincenters[-1]
plt.xlabel('Dose [%s]' % 'cGy')
plt.ylabel('Volume [%s]' % '%')
if dvh.name:
plt.legend(loc='lower center', bbox_to_anchor=(0, 1, 5, 5))
# Set the range values for x and y axis
ax.set_ylim([0, 105])
ax.set_xlim([0, max_xlim + 3])
# Create the grids on the plot
major_ticks_y = np.arange(0, 105, 20)
minor_ticks_y = np.arange(0, 105, 5)
major_ticks_x = np.arange(0, max_xlim + 250, 1000)
minor_ticks_x = np.arange(0, max_xlim + 250, 250)
ax.set_xticks(major_ticks_x)
ax.set_xticks(minor_ticks_x, minor=True)
ax.set_yticks(major_ticks_y)
ax.set_yticks(minor_ticks_y, minor=True)
ax.grid(which='minor', alpha=0.2)
ax.grid(which='major', alpha=0.5)
# Add the legend at the bottom left of the graph
if len(self.selected_rois) != 0:
ax.legend(loc='upper left', bbox_to_anchor=(-0.1, -0.15), ncol=4)
plt.subplots_adjust(bottom=0.3)
return fig
status_id_df = result[['Positivity', 'status_id']].drop_duplicates().sort_values('status_id')
status_to_id = dict(status_id_df.values)
id_to_status = dict(status_id_df[['status_id', 'Positivity']].values)
result.head()
'''
def accuracy_summary(pipeline, X_train, y_train, X_test, y_test):
sentiment_fit = pipeline.fit(X_train, y_train)
y_pred = sentiment_fit.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("\n\nΒαθμολογία Ακρίβειας: {0:.2f}%".format(accuracy*100))
return accuracy
cv = CountVectorizer()
rf = RandomForestClassifier(class_weight="balanced")
n_features = np.arange(10000,25001,5000)
def nfeature_accuracy_checker(vectorizer=cv, n_features=n_features, stop_words=None, ngram_range=(1, 1), classifier=rf):
result = []
print(classifier)
print("\n")
for n in n_features:
vectorizer.set_params(stop_words=STOPWORDS, max_features=n, ngram_range=ngram_range)
checker_pipeline = Pipeline([
('vectorizer', vectorizer),
('classifier', classifier)
])
print("Αποτελέσματα Ελέγχου για {} χαρακτηριστικά".format(n))
nfeature_accuracy = accuracy_summary(checker_pipeline, X_train, y_train, X_test, y_test)
result.append((n,nfeature_accuracy))
return result
def allTheAgents(path):
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %I:%M:%S %p',
level=logging.DEBUG)
names = []
for i in os.listdir(path):
if os.path.isfile(os.path.join(
path, i)) and 'trajectory-generate-aSs-' in i and ".zip" in i:
names.append(i)
names = sorted_nicely(names)
total_distances = []
numb = 0
logging.debug("Analysing Trajectories...")
for i in tqdm.tqdm(range(len(names))):
name = names[i]
numb += 1
# name = "trajectory-generatedPoints-" + str(numb) + "-" + str(numb) + ".zip"
trajectories_label, json_file, id_label = reanInfo(path + name)
# number = 0
# while number < len(id_label):
# real points
lat_real = []
lng_real = []
# generated points
lat_generated = []
lng_generated = []
label_real = []
label_generated = []
for labels in trajectories_label:
for el in json_file[labels]["real"]:
if el[0] not in lat_real:
lat_real.append(el[0])
lng_real.append(el[1])
label_real.append(json_file[labels]["id"])
for el in json_file[labels]["generated"]:
if el[0] not in lat_generated:
lat_generated.append(el[0])
lng_generated.append(el[1])
label_generated.append(json_file[labels]["id"])
distance_per_trajectories = {}
# now for every trajectory compute the distance of the generated distance
for i in range(len(label_real)):
index = [
j for j, x in enumerate(label_generated) if x == label_real[i]
]
distances = []
for ind in index:
a = np.array((lat_real[i], lng_real[i]))
b = np.array((lat_generated[ind], lng_generated[ind]))
value = np.linalg.norm(a - b) * 100000
value = pow(value, 2)
distances.append(value)
array = np.array(distances)
distance_per_trajectories.update({i: array})
total_distances.append(distance_per_trajectories)
df = DataFrame(columns=['gen', 'tra', "ind", 'distance'])
x = []
x = np.arange(0, len(total_distances))
i = 0
number_of_trajectories = 0
for el in total_distances:
number_of_trajectories = len(el.keys())
for k in el.keys():
array = el[k]
q = len(array)
for qq in range(q):
d = {"gen": i, "tra": k, "ind": qq, "distance": array[qq]}
dfs = DataFrame(data=d, index=[i])
df = df.append(dfs)
i += 1
sns.set_style("darkgrid")
df = df[df.columns].astype(float)
# g = sns.lmplot(x="gen", y="MSD", hue="tra", data=df, scatter_kws={"s": 1}, fit_reg=False)
# g.set(ylim=(0, 0.0000004))
for tra in range(number_of_trajectories):
a = df.loc[df['tra'] == tra]
g = sns.lmplot(x="gen",
y="distance",
hue="ind",
data=a,
scatter_kws={"s": 1},
fit_reg=False)
g.set(ylim=(0, 120))
plt.show()
