def plotting(sim_context1,sim_context2,diff,data_df,total_samples):
plt.plot(sim_context1,label="Context 1")
plt.plot(sim_context2,label="Context 2")
x_labels_word1 = data_df["word1"]
x_labels_word2 = data_df["word2"]
xlabels = [0] * total_samples
xticks_x = [0] * total_samples
for wp in range (total_samples):
xlabels[wp] = x_labels_word1[wp]+ "\n"+x_labels_word2[wp]
xticks_x[wp] = wp+1
plt.plot(diff,label="Difference")
plt.legend(loc='center right')
# Add title and x, y labels
plt.title("Elmo Embedding Model Results", fontsize=16, fontweight='bold')
plt.xlabel("Word")
plt.ylabel("Similarity")
plt.xticks(xticks_x, xlabels)
plt.show()
def getGraph():
for i, clf in enumerate((svm, rbf_svc, rbf_svc_tunning)):
# Se grafican las fronteras
plt.subplot(2, 2, i + 1)
plt.subplots_adjust(wspace=0.4, hspace=0.4)
Z = clf.predict(np.c_[x_matrizSetEntrenamientoVect, y_clases])
#Color en las gráficas
Z = Z.reshape(x_matrizSetEntrenamientoVect.shape)
plt.contourf(x_matrizSetEntrenamientoVect,
y_clases,
Z,
cmap=plt.cm.Paired,
alpha=0.8)
#Puntos de entrenamiento
plt.scatter(x_matrizSetEntrenamientoVect[:, 0],
x_matrizSetEntrenamientoVect[:, 1],
c=y_clases,
cmap=plt.cm.Paired)
plt.xlabel('Longitud Sepal')
plt.ylabel('Peso Sepal')
plt.xlim(x_matrizSetEntrenamientoVect.min(),
x_matrizSetEntrenamientoVect.max())
plt.ylim(y_clases.min(), y_clases.max())
plt.xticks(())
plt.yticks(())
plt.title(titles[i])
plt.show()
def plot():
plt.figure(figsize=(20, 10))
width = 0.5
index = np.arange(26)
print 'SUM PLOT 1', sum(row[0] for row in data)
print 'SUM PLOT 2', sum(row[1] for row in data)
print 'SUM PLOT 3', sum(row[2] for row in data)
print data[0]
p0 = plt.bar(index, data[0], width, color='y') # people
p1 = plt.bar(index, data[1], width, color='g') # nature
p2 = plt.bar(index, data[2], width, color='r') # activity
p3 = plt.bar(index, data[3], width, color='b') # food
p4 = plt.bar(index, data[4], width, color='c') # symbols
p5 = plt.bar(index, data[5], width, color='m') # objects
p6 = plt.bar(index, data[6], width, color='k') # flags
p7 = plt.bar(index, data[7], width, color='w') # uncategorized
plt.ylabel('Usage')
plt.title('Emoji category usage per city')
plt.xticks(index + width/2.0, cities)
plt.yticks(np.arange(0, 1, 0.1))
plt.legend((p0[0], p1[0], p2[0], p3[0], p4[0], p5[0], p6[0], p7[0]), categories_names)
plt.show()
def test_psv_dataset_tfm_segmentation_cropped():
from psv.ptdataset import PsvDataset, TFM_SEGMENTATION_CROPPED
ds = PsvDataset(transform=TFM_SEGMENTATION_CROPPED)
assert len(ds) == 956, "The dataset should have this many entries"
mb = ds[0]
image = mb['image']
mask = mb['mask']
assert isinstance(image, torch.Tensor)
assert isinstance(mask, torch.Tensor)
assert mask.shape[-2:] == image.shape[-2:]
# Hard to test due to randomness....
PLOT=True
if PLOT:
from matplotlib.pylab import plt
import torchvision.transforms.functional as F
a = ds.get_annotation(0)
plt.figure()
plt.suptitle('Visualizing test_psv_dataset_tfm_segmentation_cropped, close if ok')
plt.subplot(121)
plt.imshow(F.to_pil_image(image))
plt.title('image')
plt.subplot(122)
plt.imshow(a.colors[mask.numpy()])
plt.title('mask')
plt.show()
def plot_first_factors(X_data, y_data, analysis_type="lda"):
"""Generate scatterplot of two principal components (pca or lda) of data set."""
le = preprocessing.LabelEncoder()
le.fit(y_data)
colours = [
'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'darkgreen',
'darkorange', 'yellow', 'black'
]
if analysis_type == "pca":
transform = PCA(n_components=2)
XX_data = transform.fit(X_data).transform(X_data)
elif analysis_type == "lda":
transform = LinearDiscriminantAnalysis(n_components=2)
XX_data = transform.fit(X_data, y_data).transform(X_data)
else:
print("Type", analysis_type,
"not recognised, use either 'pca' or 'lda'.")
return
plt.figure()
for i, j in enumerate(le.classes_):
plt.scatter(XX_data[y_data == j, 0],
XX_data[y_data == j, 1],
alpha=0.8,
color=colours[i],
label=str(j))
plt.legend(loc='best', shadow=False, scatterpoints=1)
plt.title(analysis_type)
def graph(train_df, test_df, p_forecast, f_forecast, metric, key):
fig = plt.figure(figsize=(40,10))
forecast_ds = np.array(f_forecast["ds"])
print(len(forecast_ds))
print(len(train_df))
forecast_ds = forecast_ds[int(train_df["values"].count()):]
plt.plot(np.array(train_df["ds"]), np.array(train_df["y"]),'b', label="train", linewidth=3)
plt.plot(np.array(test_df["ds"]), np.array(test_df["y"]), 'k', label="test", linewidth=3)
plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_raw_" + metric + ".png", transparent=True)
prophet = np.array(p_forecast["yhat"])
prophet_upper = np.array(p_forecast["yhat_upper"])
prophet_lower = np.array(p_forecast["yhat_lower"])
fourier = f_forecast["yhat"]
fourier = fourier[len(train_df["values"]):]
print(len(forecast_ds))
print(len(fourier))
plt.plot(forecast_ds, fourier, 'g', label="fourier_yhat", linewidth=3)
plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_fourier_" + metric + ".png", transparent=True)
prophet = prophet[len(train_df["values"]):]
prophet_upper = prophet_upper[len(train_df["values"]):]
prophet_lower = prophet_lower[len(train_df["values"]):]
plt.plot(forecast_ds, prophet, '*y', label="prophet_yhat", linewidth=3)
plt.plot(forecast_ds, prophet_upper, 'y', label="yhat_upper", linewidth=3)
plt.plot(forecast_ds, prophet_lower, 'y', label="yhat_lower", linewidth=3)
plt.plot()
plt.xlabel("Timestamp")
plt.ylabel("Value")
plt.legend(loc=1)
plt.title("Prophet Model Forecast")
plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_compare_" + metric + ".png", transparent=True)
plt.close()
fig = plt.figure(figsize=(40,10))
forecast_ds = np.array(f_forecast["ds"])
forecast_ds = forecast_ds[len(train_df["values"]):]
plt.plot(np.array(train_df["ds"]), np.array(train_df["y"]),'b', label="train", linewidth=3)
plt.plot(np.array(test_df["ds"]), np.array(test_df["y"]), 'k', label="test", linewidth=3)
prophet = np.array(p_forecast["yhat"])
prophet_upper = np.array(p_forecast["yhat_upper"])
prophet_lower = np.array(p_forecast["yhat_lower"])
prophet = prophet[len(train_df["values"]):]
prophet_upper = prophet_upper[len(train_df["values"]):]
prophet_lower = prophet_lower[len(train_df["values"]):]
plt.plot(forecast_ds, prophet, '*y', label="prophet_yhat", linewidth=3)
plt.plot(forecast_ds, prophet_upper, 'y', label="yhat_upper", linewidth=3)
plt.plot(forecast_ds, prophet_lower, 'y', label="yhat_lower", linewidth=3)
plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_prophet_" + metric + ".png", transparent=True)
plt.close()
def plot_error(self, train_errors):
n = len(train_errors)
training, = plt.plot(range(n), train_errors, label="Training Error")
plt.legend(handles=[training])
plt.title("Error Plot")
plt.ylabel('Error')
plt.xlabel('Iterations')
plt.show()
def test_psv_dataset_crop_and_pad():
import psv.ptdataset as P
TFM_SEGMENTATION_CROPPED = psv.transforms.Compose(
psv.transforms.ToSegmentation(),
# Crop in on the facades
psv.transforms.SetCropToFacades(pad=20, pad_units='percent', skip_unlabeled=True, minsize=(512, 512)),
psv.transforms.ApplyCrop('image'),
psv.transforms.ApplyCrop('mask'),
# Resize the height to fit in the net (with some wiggle room)
# THIS is the test case -- the crops will not usually fit anymore
psv.transforms.Resize('image', height=400),
psv.transforms.Resize('mask', height=400, interpolation=P.Image.NEAREST),
# Reandomly choose a subimage
psv.transforms.SetRandomCrop(512, 512),
psv.transforms.ApplyCrop('image'),
psv.transforms.ApplyCrop('mask', fill=24), # 24 should be unlabeled
psv.transforms.DropKey('annotation'),
psv.transforms.ToTensor('image'),
psv.transforms.ToTensor('mask', preserve_range=True),
)
ds = P.PsvDataset(transform=TFM_SEGMENTATION_CROPPED)
assert len(ds) == 956, "The dataset should have this many entries"
mb = ds[0]
image = mb['image']
mask = mb['mask']
assert isinstance(image, torch.Tensor)
assert isinstance(mask, torch.Tensor)
assert mask.shape[-2:] == image.shape[-2:]
# Hard to test due to randomness....
PLOT=True
if PLOT:
from matplotlib.pylab import plt
import torchvision.transforms.functional as F
a = ds.get_annotation(0)
plt.figure()
plt.suptitle('Visualizing test_psv_dataset_tfm_segmentation_cropped,\n'
'close if ok \n '
'confirm boundary is marked unlabeled')
plt.subplot(121)
plt.imshow(F.to_pil_image(image))
plt.title('image')
plt.subplot(122)
plt.imshow(a.colors[mask.numpy()])
plt.title('mask')
plt.show()
def display_digit(X_data, y_data=None, i=0):
"""Display the Xi image, optionally with the corresponding yi label."""
plt.close('all')
Xi = X_data[i]
side = np.sqrt(Xi.size).astype(int)
data = np.array(Xi).reshape((side, side))
plt.imshow(data, cmap='Greys', interpolation='nearest')
plt.title("y = " + str(y_data[i]))
plt.show()
def plot_accuracy(self, train_acc, test_acc):
n = len(train_acc)
plt.plot(range(n), train_acc, label="train")
plt.plot(range(n), test_acc, label="test")
plt.legend(loc='lower right')
plt.title("Overfit")
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.show()
def plot_median_profile():
# Plot median line profile
plt.plot(bseg.dw, bseg.s, '.', label='Median Stellar Spectrum')
plt.plot(bseg.dw, bseg.model, '-', label='Median Telluric Model')
plt.title('Median Line Profile')
plt.xlabel('Distance From Line Center (A)')
yl = list(plt.ylim())
yl[1] = 1.05
plt.ylim(*yl)
def plot_gallery(images, titles, h, w, n_row=3,n_col=4):
plt.figure(figsize=(1.8*n_col, 2.4*n_row))
plt.subplots_adjust(bottom=0,left=.01,right=.99,top=.90,hspace=.35)
for i in range(n_row * n_col):
plt.subplot(n_row,n_col,i+1)
plt.imshow(images[i].reshape(h,w),cmap=plt.cm.gray)
plt.title(titles[i],size=12)
plt.xticks(())
plt.yticks(())
def plot_median_profile():
# Plot median line profile
plt.plot(bseg.dw,bseg.s,'.',label='Median Stellar Spectrum')
plt.plot(bseg.dw,bseg.model,'-',label='Median Telluric Model')
plt.title('Median Line Profile')
plt.xlabel('Distance From Line Center (A)')
yl = list(plt.ylim())
yl[1] = 1.05
plt.ylim(*yl)
def Test2():
t = np.linspace(0,10,100)
x = np.sin(t)
plt.plot(t, x)
plt.title('sin(x)')
plt.xlabel('time (s)')
plt.ylabel('magnitude')
plt.show()
def plot_spectrum():
# Plot telluric lines and fits
plt.plot(spec['w'], spec['s'], label='Stellar Spectrum')
plt.plot(spec['w'], mod, label='Telluric Model')
plt.plot(spec['w'], spec['s'] - mod + 0.5, label='Residuals')
plt.xlim(6275, 6305)
plt.ylim(0.0, 1.05)
plt.xlabel('Wavelength (A)')
plt.ylabel('Intensity')
plt.title('Telluric Lines')
def plot_spectrum():
# Plot telluric lines and fits
plt.plot(spec['w'],spec['s'],label='Stellar Spectrum')
plt.plot(spec['w'],mod,label='Telluric Model')
plt.plot(spec['w'],spec['s']-mod+0.5,label='Residuals')
plt.xlim(6275,6305)
plt.ylim(0.0,1.05)
plt.xlabel('Wavelength (A)')
plt.ylabel('Intensity')
plt.title('Telluric Lines')
def plotting(self, pressurelattice, invasionlattice, pressure,
number_of_clusters):
from matplotlib.pylab import plt
#Plotting the invasionlattice
plt.figure(2)
plt.imshow(invasionlattice, cmap='Greys', interpolation='nearest')
plt.title("Invasion lattice")
plt.colorbar()
plt.savefig(self.pathsimulation + "invasionlattice.png",
bbox_inches="tight")
plt.close()
#plotting the pressure
plt.figure(5)
plt.plot(pressure)
plt.xlabel('Time')
plt.ylabel('Pressure')
plt.title('P(t)')
plt.savefig(self.pathsimulation + "pressure.png", bbox_inches="tight")
plt.close()
#plotting the clusterlattice
plt.figure(6)
plt.imshow(self.lw, interpolation='nearest')
plt.title("Clusterlattice")
plt.colorbar()
plt.savefig(self.pathsimulation + "clusterlattice.png",
bbox_inches="tight")
plt.close()
#Temporal diagram
plt.figure(7)
plt.imshow(self.temporalplot, interpolation='nearest')
plt.title('Temporal diagram')
plt.colorbar()
plt.savefig(self.pathsimulation + "temporal.png", bbox_inches="tight")
plt.close()
#Plotting pressure distribution in the cell.
plt.figure(3)
plt.hist(pressurelattice.ravel(), bins=30, fc='k', ec='k')
plt.savefig(self.pathsimulation + "pressuredistribution.png",
bbox_inches="tight")
plt.close()
#Plotting the number of clusters as a function of interation.
plt.figure(1)
plt.plot(number_of_clusters)
plt.xlabel('Iteration number/time')
plt.ylabel('Number of clusters')
plt.title('Number_of_cluster(t)')
plt.savefig(self.pathsimulation + "clusterN.png", bbox_inches="tight")
plt.close()
def plot(ranks):
plt.figure(figsize=(20, 10))
plt.title("A2.3 PageRank (s-Sensibility)")
plt.xlabel("Node ID")
plt.ylabel("Pagerank")
for row in ranks:
plt.plot(row)
plt.legend(['s = %.2f' % s for s in numpy.arange(0.0, 1.0, 0.05)],
loc='upper right',
prop={'size': 7})
plt.savefig("submission/pagerank.png")
def _build_plot_static(self, metric_group):
metrics = self.get_metrics_history()
if metric_group not in metrics:
raise ValueError("can't find metric group")
for name, values in metrics[metric_group].items():
plt.plot(values, label=name)
plt.legend(loc='best')
plt.title(metric_group, fontsize=16, fontweight='bold')
plt.xlabel("Generations")
plt.show()
return None
def saveMagPhaseImage(self, image, filename):
mag = absolute(image).astype('float')
phase = angle(image).astype('float')
plt.subplot(211)
plt.imshow(mag, cmap=cm.Greys_r)
plt.title('Magnitude')
plt.axis('off')
plt.subplot(212)
plt.imshow(phase, cmap=cm.Greys_r)
plt.title('Phase')
plt.axis('off')
plt.savefig(filename)
def visual_update_analysis(
df: pd.DataFrame
) -> Tuple[Dict[str, str], List[Dict[str, Union[str, float]]]]:
summary = []
template_vars = {}
df = df.rename(columns={'date': 'ds'})
if 'asa_impressions' in df.columns:
df['impressions'] = df['search_impressions'] - df['asa_impressions']
df['conversions'] = df['search_downloads'] - df['asa']
else:
df['impressions'] = df['search_impressions']
df['conversions'] = df['search_downloads']
df['y'] = df['conversions'] / df['impressions']
df.index = df['ds']
if options.weekly:
df = df.resample('W').apply(safe_mean)
df = handle_outliers(df.copy())
time_regressors = []
for _, row in df.iterrows():
if row['update'] == 'visual' or row['update'] == 'all':
additional_regressor = '{} (visual)'.format(
str(row['ds']).split(" ")[0])
df[additional_regressor] = [
1 if other_row['ds'] >= row['ds'] else 0
for _, other_row in df.iterrows()
]
time_regressors.append(additional_regressor)
model = create_model('sherlock_visual', df, 1.0, False, time_regressors)
conversion_model = fit_beta_regression(model, df)
fig = plot_nowcast(conversion_model, [
row['ds'] for _, row in df.iterrows()
if row['update'] == 'visual' or row['update'] == 'all'
])
plt.title('Conversion & Visual Updates')
template_vars['visual_model'] = figure_to_base64(fig)
summary.extend(
summary_from_model_regressors(conversion_model, time_regressors))
seasonality = {}
for period, fig in plot_seasonality(conversion_model,
alpha=options.alpha,
plot_kwargs={}).items():
seasonality[int(period)] = figure_to_base64(fig)
template_vars['conversion_seasonality'] = seasonality
return template_vars, summary
def plotting(self,pressurelattice,invasionlattice,pressure,number_of_clusters):
from matplotlib.pylab import plt
#Plotting the invasionlattice
plt.figure(2)
plt.imshow(invasionlattice, cmap='Greys',interpolation='nearest')
plt.title("Invasion lattice")
plt.colorbar()
plt.savefig(self.pathsimulation + "invasionlattice.png", bbox_inches="tight")
plt.close()
#plotting the pressure
plt.figure(5)
plt.plot(pressure)
plt.xlabel('Time')
plt.ylabel('Pressure')
plt.title('P(t)')
plt.savefig(self.pathsimulation +"pressure.png", bbox_inches="tight")
plt.close()
#plotting the clusterlattice
plt.figure(6)
plt.imshow(self.lw, interpolation='nearest')
plt.title("Clusterlattice")
plt.colorbar()
plt.savefig(self.pathsimulation +"clusterlattice.png", bbox_inches="tight")
plt.close()
#Temporal diagram
plt.figure(7)
plt.imshow(self.temporalplot,interpolation='nearest')
plt.title('Temporal diagram')
plt.colorbar()
plt.savefig(self.pathsimulation +"temporal.png", bbox_inches="tight")
plt.close()
#Plotting pressure distribution in the cell.
plt.figure(3)
plt.hist(pressurelattice.ravel(), bins=30, fc='k', ec='k')
plt.savefig(self.pathsimulation +"pressuredistribution.png", bbox_inches="tight")
plt.close()
#Plotting the number of clusters as a function of interation.
plt.figure(1)
plt.plot(number_of_clusters)
plt.xlabel('Iteration number/time')
plt.ylabel('Number of clusters')
plt.title('Number_of_cluster(t)')
plt.savefig(self.pathsimulation +"clusterN.png", bbox_inches="tight")
plt.close()
def random_tensor(shape=None,
sparsity=0.5,
seed=1234,
distributed='normal',
normal=None,
uniform=None,
plot=True):
np.random.seed(seed)
tensor_size = prod(shape)
if distributed == 'normal':
mean, std = normal
data = np.random.normal(mean, std, tensor_size)
if plot == True:
n, bins, patches = plt.hist(data,
30,
normed=True,
facecolor='blue',
alpha=0.5)
y = mlab.normpdf(bins, mean, std)
plt.plot(bins, y, 'r--')
plt.xlabel('Expectation')
plt.ylabel('Probability')
plt.title('Histogram of Normal Distribution:$\mu =' + str(mean) +
'$, $\sigma=' + str(std) + '$')
plt.axvline(norm.ppf(sparsity) * std + mean)
plt.show()
data[data <= norm.ppf(sparsity) * std + mean] = 0
if distributed == 'uniform':
low, high = uniform
data = np.random.uniform(low, high, size=tensor_size)
if plot == True:
n, bins, patches = plt.hist(data,
30,
normed=True,
facecolor='blue',
alpha=0.5)
plt.xlabel('Expectation')
plt.ylabel('Probability')
plt.title('Histogram of Uniform Distribution:$low =' + str(low) +
'$, $high =' + str(high) + '$')
plt.axvline((high - low) * sparsity)
plt.show()
data[data <= (high - low) * sparsity] = 0
return tensor(data.reshape(shape))
def plot_average(collected_results, versions, args, plot_std=True):
test_type = args.test_type
model_name = args.model
means, stds = [], []
for version in versions:
data = collected_results[version]
if (plot_std):
means.append(np.mean(data))
stds.append(np.std(data))
else:
means.append(data)
means = np.array(means)
stds = np.array(stds)
if (test_type == "size" or test_type == "allsize"):
x = ["0%", "20%", "40%", "60%", "80%", "100%"]
elif (test_type == "accdomain" or test_type == "moredomain"):
x = [0, 1, 2, 3, 4]
else:
x = versions
color = 'blue'
plt.plot(x, means, color=color)
if (plot_std):
plt.fill_between(x,
means - stds,
means + stds,
alpha=0.1,
edgecolor=color,
facecolor=color,
linewidth=1,
antialiased=True)
plt.xticks(np.arange(len(x)), x, fontsize=18)
plt.yticks(fontsize=18)
plt.xlabel(XLABELS[test_type], fontsize=18)
plt.ylabel('average absolute effect size', fontsize=18)
plt.title("Influence of {} on bias removal \nfor {}".format(
TITLES[test_type], MODEL_FORMAL_NAMES[model_name]),
fontsize=18)
plt.tight_layout()
plot_path = os.path.join(
args.eval_results_dir, "plots",
"{}-{}-avg{}.png".format(model_name, test_type,
"-std" if plot_std else ""))
plt.savefig(plot_path)
def showMagPhasePlot(self, t, x):
mag = absolute(x)
phase = angle(x)
plt.subplot(211)
plt.plot(t, mag)
plt.ylabel('Magitude')
plt.title('SSPF Sequence')
plt.grid(True)
plt.subplot(212)
plt.plot(t, phase)
plt.xlabel('Off-Resonance (Hz)')
plt.ylabel('Phase')
plt.grid(True)
plt.show()
def saveMagPhasePlot(self, t, x, filename):
mag = absolute(x).astype('float')
phase = angle(x).astype('float')
plt.subplot(211)
plt.plot(t, mag)
plt.ylabel('Magitude')
plt.title('SSPF Sequence')
plt.grid(True)
plt.subplot(212)
plt.plot(t, phase)
plt.xlabel('Off-Resonance (Hz)')
plt.ylabel('Phase')
plt.grid(True)
plt.savefig(filename)
def plt_score(history):
plt.figure()
plt.plot()
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.savefig('acc.png')
# loss
plt.figure()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.savefig('loss.png')
def visualize(img, G, vertices):
plt.imshow(img, cmap='gray')
# draw edges by pts
for (s, e) in G.edges():
vals = flatten([[v] for v in G[s][e].values()])
for val in vals:
ps = val.get('pts', [])
plt.plot(ps[:, 1], ps[:, 0], 'green')
# draw node by o
node, nodes = G.node(), G.nodes
# deg = G.degree
# ps = np.array([node[i]['o'] for i in nodes])
ps = np.array(vertices)
plt.plot(ps[:, 1], ps[:, 0], 'r.')
# title and show
plt.title('Build Graph')
plt.show()
def visualize(img, G, vertices):
plt.imshow(img, cmap='gray')
# draw edges by pts
for (s, e) in G.edges():
vals = flatten([[v] for v in G[s][e].values()])
for val in vals:
ps = val.get('pts', [])
plt.plot(ps[:, 1], ps[:, 0], 'green')
# draw node by o
node, nodes = G.node(), G.nodes
# deg = G.degree
# ps = np.array([node[i]['o'] for i in nodes])
ps = np.array(vertices)
plt.plot(ps[:, 1], ps[:, 0], 'r.')
# title and show
plt.title('Build Graph')
plt.show()
def augmentation_visualize_and_save(config,
images,
images_names,
path,
times: int = 2):
"""
Visualization of image enhancements.
:param config: configuration from yaml file.
:param images: images to be augmented.
:param images_names: corresponding names of the images.
:param path: the root where the augmented pictures will be saved.
:param times: how many times each image getting augmented.
:return:
"""
rows = len(images)
cols = times + 1
for (index, image), name in zip(enumerate(images), images_names):
plt.subplot(rows, cols, index * cols + 1)
plt.axis('off')
plt.title(name)
_image = bgr2rgb_using_opencv(image)
plt.imshow(_image)
for col in range(1, cols):
plt.subplot(rows, cols, index * cols + col + 1)
plt.axis('off')
plt.title("Augmented NO. " + str(col))
# augment image
augmented_image = augment_image_using_imgaug(_image, config)
plt.imshow(augmented_image)
# Save the full figure
isExists = os.path.exists(path)
if not isExists:
os.makedirs(path)
now_time = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
savefig(os.path.join(path, "%s_Comp.png" % now_time), dpi=600)
# Clear the current figure
plt.clf()
plt.cla()
plt.close()
def display_populations(self,
top_k=10,
max_chromosome_len=1024,
rounding=None):
for pop_idx, population in enumerate(self._populations):
num_chromosomes = min(len(population), top_k)
heatmap = []
gene_max = 0
for cidx, chromosome in enumerate(population):
genes = []
for gene in chromosome[:max_chromosome_len]:
if isinstance(rounding, type(None)):
genes.append(str(gene))
elif rounding > 0:
genes.append(round(float(gene), rounding))
else:
genes.append(int(gene))
gene_max = max(gene_max, gene)
heatmap.append(genes)
if cidx > num_chromosomes:
break
fig, ax = plt.subplots()
im = ax.imshow(heatmap,
interpolation='nearest',
cmap="viridis",
aspect='auto')
# gradient bar
cbar = ax.figure.colorbar(im, ax=ax)
cbar.ax.set_ylabel('Gene value', rotation=-90, va="bottom")
plt.title(f'Population - top {num_chromosomes}',
fontsize=16,
fontweight='bold')
plt.xlabel("Genes")
plt.ylabel("Chromosome")
# fig.tight_layout()
plt.show()
def bar_graph(category, age_grp, sex, x, y, year=None, country=None):
plt.figure()
plt.ylabel('ATE = Y1 - Y0')
plt.xlabel('Years')
plt.bar(range(len(x)), x, align='center')
plt.xticks(range(len(x)), y, rotation='vertical')
if country:
plt.title("%s Suicide Rates for WC; %s ages %s" %
(country, sex, age_grp))
name = country + sex + age_grp + '.png'
# plt.show()
plt.tight_layout()
plt.savefig('./graphs/Countries' + '/' + sex + '/' +
name.replace(' ', '_'))
elif year:
plt.title("Change in Suicide Rates per Country in %s; %s ages %s" %
(year, sex, age_grp))
name = category + sex + str(year) + age_grp + '.png'
# plt.show()
plt.tight_layout()
plt.savefig('./graphs/' + category + '/' + sex + '/' + str(year) +
'/' + name.replace(' ', ''))
else:
plt.title("Change in Suicide Rates in %s Countries; %s ages %s" %
(category, sex, age_grp))
name = category + sex + age_grp + '.png'
# plt.show()
plt.tight_layout()
plt.savefig('./graphs/' + category + '/' + sex + '/' +
name.replace(' ', ''))
def print_all_results(collected_results, versions, args):
test_type = args.test_type
model_name = args.model
for test_name in collected_results:
test_results = collected_results[test_name]
x, y = [], []
for version in versions:
if (version in test_results):
x.append(version)
y.append(test_results[version]['mean'])
plt.plot(x, y, label=test_name)
plt.xticks(np.arange(len(x)), x)
plt.xlabel(XLABELS[test_type])
plt.ylabel('average absolute effect size')
plt.legend(loc='best')
plt.title("SEAT effect sizes on {} with {}".format(model_name,
TITLES[test_type]))
plot_path = os.path.join(args.eval_results_dir, "plots",
"{}-{}.png".format(model_name, test_type))
plt.savefig(plot_path)
def plot_scatter_annotate(data, labels, title):
plt.figure(figsize=(10, 10))
assert data.shape[0] == len(labels), 'size mismatch'
plt.subplots_adjust(bottom=0.1)
plt.scatter(data[:, 0],
data[:, 1],
marker='o',
s=100,
cmap=plt.get_cmap('Spectral'))
plt.title(title)
for label, x, y in zip(labels, data[:, 0], data[:, 1]):
plt.annotate(label,
xy=(x, y),
xytext=(-20, 20),
textcoords='offset points',
ha='right',
va='bottom',
bbox=dict(boxstyle='round,pad=0.5',
fc='yellow',
alpha=0.5),
arrowprops=dict(arrowstyle='->',
connectionstyle='arc3,rad=0'))
plt.show()
def getGraph():
for i, clf in enumerate((svm, rbf_svc, rbf_svc_tunning)):
# Se grafican las fronteras
plt.subplot(2, 2, i + 1)
plt.subplots_adjust(wspace=0.4, hspace=0.4)
Z = clf.predict(np.c_[x_matrizSetEntrenamientoVect, y_clases])
#Color en las gráficas
Z = Z.reshape(x_matrizSetEntrenamientoVect.shape)
plt.contourf(x_matrizSetEntrenamientoVect, y_clases, Z, cmap=plt.cm.Paired, alpha=0.8)
#Puntos de entrenamiento
plt.scatter(x_matrizSetEntrenamientoVect[:, 0], x_matrizSetEntrenamientoVect[:, 1], c=y_clases, cmap=plt.cm.Paired)
plt.xlabel('Longitud Sepal')
plt.ylabel('Peso Sepal')
plt.xlim(x_matrizSetEntrenamientoVect.min(), x_matrizSetEntrenamientoVect.max())
plt.ylim(y_clases.min(), y_clases.max())
plt.xticks(())
plt.yticks(())
plt.title(titles[i])
plt.show()
def plot_result(filename='glances.csv'):
import pandas as pd
from matplotlib.pylab import plt
data = pd.read_csv(filename)
mem_used = data['mem_used'].apply(lambda x: float(x) / (10**9))
plt.figure(1)
plt.subplot(121)
mem_used.plot(color="r", linestyle="-", linewidth=1)
plt.xlabel('time step')
plt.ylabel('GB')
plt.title('mem_used')
plt.subplot(122)
gpu_0_proc = data['gpu_0_proc']
gpu_0_proc.plot(color="b", linestyle="-", linewidth=1)
plt.xlabel('time step')
plt.ylabel('proc')
plt.title('gpu_0_proc')
plt.show()
print("mean mem_used:{},mean_gpu_0_proc:{}".format(mem_used.mean(),
gpu_0_proc.mean()))
def saveWaterFatImage(self, filename):
mag = np.absolute(self.water).astype('float')
phase = np.angle(self.water).astype('float')
mag2 = np.absolute(self.fat).astype('float')
phase2 = np.angle(self.fat).astype('float')
plt.subplot(221)
plt.imshow(mag, cmap=cm.Greys_r)
plt.title('Water Magnitude')
plt.axis('off')
plt.subplot(222)
plt.imshow(phase, cmap=cm.Greys_r)
plt.title('Water Phase')
plt.axis('off')
plt.subplot(223)
plt.imshow(mag2, cmap=cm.Greys_r)
plt.title('Fat Magnitude')
plt.axis('off')
plt.subplot(224)
plt.imshow(phase2, cmap=cm.Greys_r)
plt.title('Fat Phase')
plt.axis('off')
plt.show()
def saveMagPhaseImage2(self, image1, image2, filename):
mag = absolute(image1).astype('float')
phase = angle(image1).astype('float')
mag2 = absolute(image2).astype('float')
phase2 = angle(image2).astype('float')
plt.subplot(221)
plt.imshow(mag, cmap=cm.Greys_r)
plt.title('Magnitude')
plt.axis('off')
plt.subplot(222)
plt.imshow(phase, cmap=cm.Greys_r)
plt.title('Phase')
plt.axis('off')
plt.subplot(223)
plt.imshow(mag2, cmap=cm.Greys_r)
plt.title('Magnitude')
plt.axis('off')
plt.subplot(224)
plt.imshow(phase2, cmap=cm.Greys_r)
plt.title('Phase')
plt.axis('off')
plt.savefig(filename)
xls_date = xlrd.xldate_as_tuple(float(index_name), 0)
year, month, day, hour, minute, second = xls_date
py_datetime = datetime.datetime(year, month, day, hour, minute, second)
datetime_str = py_datetime.strftime('%b-%Y')
return datetime_str
emp_data_dir_2013 = 'data/emp_data_2008_2014'
emp_files = get_files_in_directory(emp_data_dir_2013, '.csv')
df_list = []
for csv_file in emp_files:
pathname = csv_file[0]
ag_row, header_row = get_csv_row_number(pathname, 'TOTAL AGRICULTURAL')
df = pd.read_csv(pathname, sep=',', quotechar='"', skiprows=header_row-1, index_col=1, header=0)
df_list.append(df)
pertinent_dfs = []
for df in df_list:
columns_not_of_interest = ['NAICS CODES', 'TITLE']
df_columns = list(df.columns.values)
column_list = [column for column in df_columns if column not in columns_not_of_interest]
df_pert_dirty = df[column_list]
df_clean = df_pert_dirty.loc['TOTAL AGRICULTURAL', :]
df_clean_reindex = df_clean.rename(rename_index)
print(df_clean_reindex)
pertinent_dfs.append(df_clean_reindex)
s_concat = pd.concat(pertinent_dfs)
s_concat.plot(kind='bar')
plt.title('CA Agricultural Employment')
plt.xlabel('Month')
plt.ylabel('Agricultural Employment')
plt.show()
plt.plot(x, y, label="N={}".format(k))
return x, y
def exact():
W = Lea.fastMax(W0 + U, 0)
for k in range(1, 21):
if k % 5 == 0:
plt.plot(W.support(), W.pmf(), label="k={}".format(k))
W = Lea.fastMax(W + U, 0)
return W.support(), W.pmf()
plt.figure()
plt.axis([0, 20, 0, 0.3])
plt.title("Exact")
xex, yex = exact()
plt.legend()
tikz_save('waiting_time_1.tex', figureheight='5cm', figurewidth='5cm')
plt.close()
plt.figure()
plt.axis([0, 20, 0, 0.3])
plt.title("Simulation")
xsim, ysim = simulate()
plt.legend()
tikz_save('waiting_time_2.tex', figureheight='5cm', figurewidth='5cm')
plt.close()
plt.figure()
plt.axis([0, 20, 0, 0.3])
a = log(u)
b = log(1-0.4)
return int(a / b) + 1
gt = []
for i in range(10**4):
gt.append(geo())
#print gt
x = [g1,g2,g3,gt]
common_params =dict(bins=35, normed=1,histtype='bar', alpha=0.7,range=(0,18), color=['blue','green','red','orange'],align='right',label=['Muestra de 100 Geoms.','Muestra de 1000 Geoms.','Muestra de 10000 Geoms.','Muestra teorica'])
plt.subplots_adjust(hspace=.4)
#plt.title('Skinny shift - 3 at a time')
#plt.hist((g1, g2, g3, gt), **common_params)
#plt.subplot(313)
# 100 Geometricas
#plt.hist(g2, 35,normed=1, facecolor='green',alpha=0.7,width=0.2)
plt.hist(g1, 35,normed=1 , facecolor='b',alpha=0.7,width=0.2)
#plt.hist(gt,35,normed=1,facecolor='grey',alpha=0.6,width=0.2 )
#plt.hist(g3, 35,normed=1, facecolor='b',alpha=0.7,width=0.2)
plt.title('Histograma con 100 variables Aleatorias Geometricas de parametro 0.4')
plt.axvline(np.mean(g1), color='blue', linestyle='dashed', linewidth=2)
#plt.hist(x, **common_params)
#plt.legend()
plt.show()
emotion: per_emotion_data[emotion][feature]
for emotion in EMOTIONS
}
data = {
emotion: [convert_to_list(vid) for vid in data[emotion]]
for emotion in EMOTIONS
}
data = {emotion: np.array(data[emotion]) for emotion in EMOTIONS}
for emotion in EMOTIONS:
print(emotion)
print("Plotting for emotion " + emotion)
emotion_data = data[emotion]
for vid in emotion_data:
plt.plot(np.arange(len(vid)),
vid,
label=emotion,
color=colors[emotion])
plt.title(feature + " over time for subject " + subject)
# plt.legend([colors[emotion] for emotion in EMOTIONS], EMOTIONS)
plt.legend()
print('Saving plot...')
if 'Neck/Nose' in feature:
feature_name = feature.replace('Neck/Nose', 'Neck')
else:
feature_name = feature
plt.savefig(plots_dir + "/" + subject + "/" + feature_name + '.png')
plt.close()
print('Done.')
# -*- coding:utf-8 -*-
#V:Python 3.6.3
import pandas as pd
from IPython.display import display
from matplotlib.pylab import plt
data = pd.read_csv('house3.csv')
data['total_price'] = data['price'] * data['area'] / 10000
data_mean = data.groupby('district')['price'].mean()
data_count = data.groupby('district')['price'].count()
#柱状图分析各区的二手房的房价
plt.figure(figsize=(10, 6))
plt.rc('font', family='SimHei', size=13)
plt.title(u'各区域的平均二手房房价')
plt.xlabel(u'南京城区')
plt.ylabel(u'平均房价')
plt.bar(data_mean.index, data_count.values, color='g')
plt.show()
plt.figure(figsize=(10, 10))
plt.rc('font', family='SimHei', size=13)
explode = [0] * len(data_count)
explode[9] = 0.1
plt.pie(data_count,
radius=2,
autopct='%1.f%%',
shadow=True,
labels=data_mean.index,
explode=explode)
t_tuple = (TOMATOES, 'tomatoes')
lemon_tuple = (LEMONS, 'lemons')
tuple_list = [o_tuple, g_tuple, b_tuple, s_tuple, lettuce_tuple, t_tuple, lemon_tuple]
csv_paths = []
for produce_tuple in tuple_list:
filepath, produce_item = produce_tuple
csv_path = 'data\\produce\\{0}.csv'.format(produce_item)
csv_paths.append((csv_path, produce_item))
excel_to_csv(filepath, csv_path)
dfs = {}
for csv_tuple in csv_paths:
csv_path, produce_item = csv_tuple
df = pd.read_csv(csv_path, sep=',', quotechar='"', skiprows=8, header=0, index_col=0)
df1 = df.loc[2010:]
dfs[produce_item] = df1
for key in dfs:
produce_df = dfs[key]
produce_df_stacked = produce_df.stack()
produce_df_stacked.plot(kind='bar', color='c')
title = '{0} CPI'.format(key)
y_label = '{0} Average Price/lb'.format(key)
x_label = 'Month'
plt.title(title)
plt.ylabel(y_label)
plt.xlabel(x_label)
fig = gcf()
fig.set_size_inches(18.5, 14.5)
figure_name = 'plots\\{0}.png'.format(key)
fig.savefig(figure_name)
def plot(self, **kwargs):
"""A wrapper function for plotting a NetworkX graph
This function will draw a provided NetworkX graph using either the
spring layout algorithm, or by the positions provided.
Parameters
----------
pos: dict, optional, default: networkx.drawing.layout.spring_layout
A dictionary of the network's neurons as keys and their (x, y)
coordinates as corresponding values.
nodelist: list, optional, default: self.neurons
Draw only specified neurons (nodes).
node_size: int or list, optional, default: 300
The size of the plotted neurons in the network.
node_color: (color string, or array of floats), optional, default: 'r'
Can either be a single color format string (default=’r’), or a
sequence of colors with the same length as nodelist. If numeric
values are specified they will be mapped to colors using the
cmap and vmin, vmax parameters. See matplotlib.scatter for more
details.
cmap: Matplotlib colormap, optional, default: None
Colormap for mapping intensities of nodes.
alpha: float, optional, default: 1.0
The transparency of the nodes.
node_borders: (None, scalar, or sequence), optional, default: 'black'
The color(s) of the node borders.
edgelist: (collection of edge tuples), optional, default: self.connections
Draw only specified edges. By default, the edges between all
nodes will be drawn. If `[]` (i.e. empty list), then the edges
between all nodes will be omitted from the figure.
edge_alpha: float, optional, default is 1.0
The transparency of the edges.
edge_color: (color string, or array of floats), default: 'r'
Can either be a single color format string, or a sequence of
colors with the same length as edgelist. If numeric values are
specified they will be mapped to colors using the edge_cmap and
edge_vmin, edge_vmax parameters.
edge_cmap : Matplotlib colormap, optional, default: None
Colormap for mapping intensities of edges.
width: float, optional, default: 1.0
The width of the edges.
labels: bool, optional, default: True
If False, then omit node labels and edge labels.
font_size: int, optional, default: 10
The size of the font for text labels.
figsize: tuple, optional, default: (20, 20)
The size of the network figure to be plotted.
savefig: bool, optional, default: False
When True, the plotted figure will be saved to the current
working directory, in PDF format, at the default (or specified)
DPI.
dpi: int, optional, default: 600
The amount of dots per inch to use when saving the figure. In
accordance with Nature's guidelines, the default is 600.
Source: https://www.nature.com/nature/for-authors/final-submission
title: str, optional, default: None
The title of the plotted graph/network.
Returns
-------
pos: dict
A dictionary of the network's neurons as keys and their (x, y)
coordinates as corresponding values.
"""
# Get positions for all nodes
pos = kwargs.get("pos", None)
if pos is None:
print(
"A neuron position dictionary was not provided! The spring_layout function will be used to plot the network.",
file=sys.stderr)
pos = nx.spring_layout(self.network, weight="weight")
# Size of the plot
plt.figure(figsize=kwargs.get("figsize", (20, 20)))
# Nodes
cmap = kwargs.get("cmap", None)
alpha = kwargs.get("alpha", 1.0)
node_size = kwargs.get("node_size", 600)
nodelist = kwargs.get("nodelist", self.neurons)
node_color = kwargs.get("node_color", 'r')
node_borders = kwargs.get("node_borders", "black")
nx.draw_networkx_nodes(self.network,
pos,
nodelist=nodelist,
alpha=alpha,
node_size=node_size,
cmap=cmap,
node_color=node_color,
edgecolors=node_borders)
# Draw edges
width = kwargs.get("width", 1.0)
edge_alpha = kwargs.get("edge_alpha", 1.0)
edge_color = kwargs.get("edge_color", 'r')
edge_cmap = kwargs.get("edge_cmap", None)
edgelist = kwargs.get("edgelist", self.connections)
nx.draw_networkx_edges(self.network,
pos,
edgelist=edgelist,
alpha=edge_alpha,
width=width,
edge_color=edge_color,
edge_cmap=edge_cmap)
# Draw labels
if kwargs.get("labels", True):
nx.draw_networkx_labels(self.network,
pos,
font_size=kwargs.get("font_size", 10))
plt.title(kwargs.get("title", None))
plt.axis("off")
if kwargs.get("savefig", False):
plt.savefig(kwargs.get("title", "my_neuron_network.pdf"),
format="pdf",
dpi=kwargs.get("dpi", 600))
plt.show()
return pos
}
new_controller('example_configuration.cnf', 'example_controller.py', 'PIDAW', param)
# Create a motor object for simulation
motor = DC_Motor(configfile='model.cnf', controlmodule='example_controller')
# Simulate the system with an alternating step reference
ref, u, x, y = motor.simulate(30, 'steps')
# Visualize simulation
t = np.array([ii * motor.h for ii in range(len(u[0,:]))])
plt.figure(1);
plt.step(t, u[0])
limits = np.array(plt.axis())*np.array([1.,1.,1.1,1.1])
plt.axis(limits)
plt.title('Control signal(s)')
plt.figure(2);
plt.step(t, np.transpose(x))
limits = np.array(plt.axis())*np.array([1.,1.,1.1,1.1])
plt.axis(limits)
plt.title('System states')
plt.figure(3);
plt.step(t, ref[0])
plt.step(t, x[0])
limits = np.array(plt.axis())*np.array([1.,1.,1.1,1.1])
plt.axis(limits)
plt.title('Theta and reference')
plt.show()
