def plot_decision_regions(X, y, classifier, resolution=0.02):
# prepare marker and color map
markers = ('s', 'x', 'o', '^', 'v')
colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
cmap = ListedColormap(colors[:len(np.unique(y))])
# plot decision regions
x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
# generate grid point
xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
np.arange(x2_min, x2_max, resolution))
# translate features into array and predict
Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
# translate result to grid point
Z = Z.reshape(xx1.shape)
# plot contour line of grid point
plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap)
plt.xlim(xx1.min(), xx1.max())
plt.ylim(xx2.min(), xx2.max())
# plot sample by each class
for idx, cl in enumerate(np.unique(y)):
plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1], alpha=0.8, c=cmap(idx),
marker=markers[idx], label=cl)
def histogram_rgb():
img = cv2.imread("2.jpeg", )
cv2.imshow("image", img)
color = ('r', 'g', 'b')
for channel, c in enumerate(color):
hist = cv2.calcHist([img], [channel], None, [256], [0, 256])
plt.subplot(1, 3, channel + 1)
plt.title('Channel {}, color {} '.format(channel, c))
plt.plot(hist, color=c)
plt.xlim([0, 256])
plt.show()
key = cv2.waitKey(0)
def test_results():
# testing and plotting curtailment results to compare to aviva's plots
(plantType, hr, fuelAndCoalType, coolType, fgdType, state,
capac) = getKeyCurtailParams(gen, genFleet)
coeffs = getCoeffsForGenOrTech(plantType, coolType, genparam.ptCurtailed,
regCoeffs, genparam.coolDesignT)
x = np.arange(start=70, stop=110.1, step=0.1)
y = np.arange(start=20, stop=110.1, step=0.1)
xy = np.array(np.meshgrid(x, y)).reshape(2, x.shape[0] * y.shape[0]).T
metAndWaterData = pd.DataFrame({
'airF': xy[:, 0],
'rh': xy[:, 1],
'airF:rh': xy[:, 0] * xy[:, 1]
})
hourlyCurtailments = runCurtailRegression(metAndWaterData, coeffs,
genparam.incCurtailments,
plantType, coolType,
genparam.ptCurtailed)
xx, yy = np.meshgrid(x, y)
zz = np.array(hourlyCurtailments).reshape(xx.shape)
fig, ax = plt.subplots(1)
N = 10
base = plt.cm.get_cmap(plt.get_cmap('YlGn'))
color_list = base(np.linspace(0, 1, N))
cmap_name = base.name + str(N)
my_map = base.from_list(cmap_name, color_list, N)
bins = np.concatenate(([-np.inf], np.arange(start=0.1, stop=1,
step=0.1), [np.inf]))
values = np.digitize(zz, bins)
im = ax.pcolormesh(xx, yy, values, cmap=my_map)
plt.xlim(70, 110)
plt.ylim(20, 100)
cbar = fig.colorbar(im, orientation='vertical')
cbar.set_ticks([])
for j in np.arange(N + 1, step=2):
cbar.ax.text(1, j / N, j / N, ha='left', va='center')
plt.savefig('./example.png')
plt.close(fig)
def plot_winavg_vectors(data, attribute, start=0, duration=SIM_TIME, win=100):
sel = data[data.name == attribute]
index_malus = 0
for row in sel.itertuples():
pprint.pprint(row)
plt.plot(row.time,
winavg(row.value, win),
label=f"{malus[index_malus]}")
index_malus = index_malus + 1
plt.title("responseTime")
plt.xlim(start, duration)
return
def boton_alcance_horizontalf(self):
# __Variables necesarias para conseguir R (alcance horizontal)__ #
xi = int(self.entrada_posicion_x0.get())
yi = int(self.entrada_posicion_y0.get())
v0 = int(self.entrada_Rapidez_inicial.get())
angulo0 = math.radians(int(self.entrada_angulo_inicial.get()))
coseno = math.cos(angulo0)
seno = math.sin(angulo0)
vxo = v0 * coseno
vyo = v0 * seno
g = 9.8
altura = int(self.entrada_posicion_y0.get()) + (((v0 * seno)**2) /
(2 * g))
imp = (g * yi / math.pow(v0, 2))
time = (v0 / g) * (seno + math.sqrt(math.pow(seno, 2) + 2 * imp))
# __Ecuacion dividida en 4 partes para conseguir R__ #
R1 = (math.pow(v0, 2) * math.sin(2 * angulo0)) / (2 * g)
R2 = (v0 * coseno) / g
R3 = np.sqrt((math.pow((v0 * seno), 2)) + (2 * yi * g))
R = xi + R1 + R2 * R3
imprimir = (
"{0:.2f}".format(R)
) # Imprimir guarda el resultado final (R) y lo deja con solo dos decimales
print("R = ", R) # print de control
# __Estetica de la grafica__ #
mpl.suptitle('Alcance Horizontal:', fontsize=22)
mpl.subplots_adjust(top=0.80)
mpl.title(R, fontsize=18, color='C3')
mpl.xlim(0, R + 2)
mpl.ylim(-0.03, altura + 2)
mpl.xlabel("X(m)")
mpl.ylabel("Y(m)")
# __Dibujado de la curva__ #
x = np.arange(0, time, 0.001)
c_y = yi + vyo * x + (
1 / 2) * -9.8 * x**2 # Ecuacion de lanzamiento de proyectil
c_x = xi + vxo * x + (
1 / 2) * 0 * x**2 # Ecuacion de lanzamiento de proyectil
mpl.plot(c_x, c_y, "-") # lanzamiento completo
mpl.plot(R, 0, "ro")
mpl.show()
pass
def plotFeatImportance(pathOut,imp,oob,oos,method,tag=0,simNum=0,**kargs):
# plot mean imp bars with std
mpl.figure(figsize=(10,imp.shape[0]/5.))
imp=imp.sort_values('mean',ascending=True)
ax=imp['mean'].plot(kind='barh',color='b',alpha=0.25,xerr=imp['std'],
error_kw={'ecolor':'r'})
if method=='MDI':
mpl.xlim([0,imp.sum(axis=1).max()])
mpl.axvline(1./imp.shape[0],lw=1.,color='r',ls='dotted')
ax.get_yaxis().set_visible(False)
for i,j in zip(ax.patches,imp.index):
ax.text(i.get_width()/2, i.get_y()+i.get_height()/2,
j,ha='center',va='center',color='k')
mpl.title('tag='+tag+' | simNUm='+str(simNum)+' | oob='+str(round(oob,4))+' | oos='+str(round(oos,4)))
mpl.savefig(pathOut+'featImportance_'+str(simNum)+'.png',dpi=100)
mpl.clf();mpl.close()
return
def plot_roc_curve(fpr, tpr, roc_auc, title='ROC curve'):
plt.figure()
lw = 2
colors = cycle(['darkorange', 'blue', 'red', 'green', 'black', 'purple',
'yellow'])
for i, color in zip(range(len(fpr), colors)):
plt.plot(fpr[i], tpr[i], color=color, lw=lw,
label='ROC area {0:.4f}'.format(roc_auc[i]))
# plt.plot(fpr, tpr, color='darkorange', lw=lw,
# label='ROC area under curve = {}'.format(roc_auc))
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.title(title)
plt.xlabel('False positive rate')
plt.ylabel('True positive rate')
plt.legend(loc='lower right')
plt.show()
def blca(datafile,numprocs):
#run c++ blocking routine, saves txt data file with blocking data
os.system("make --silent")
os.system("mpirun -n %i blocking.out 100 3000 2 %i %s"%(nprocs,numprocs,datafile))#VMC
#os.system("mpirun -n %i blocking.out 5000 100 20000 %i %s"%(nprocs,numprocs,datafile))#DMC
#read txt file and save plot
data = np.genfromtxt(fname=datafile+'.txt')
fig=plt.figure()
plt.plot(data[:,0],data[:,2],'k+')
plt.xlabel(r'$\tau_{trial}$', size=20)
plt.ylabel(r'$\epsilon$', size=20)
plt.xlim(np.min(data[:,0]),np.max(data[:,0]))
plt.ylim(np.min(data[:,2]),np.max(data[:,2]))
fig.savefig(datafile+'.eps',format='eps')
#open plot if -p in argv
if plot_res:
os.system('evince %s%s '%(datafile+'.eps','&'))
print("plot saved : %s"%(datafile+'.eps'))
def plot_roc(y_true: List[str], y_score: List[float]) -> None:
"""Plot a ROC curve for these results"""
fpr, tpr, threshold = roc_curve(y_true, y_score, pos_label="target")
fnr = 1 - tpr
EER = fpr[np.nanargmin(np.absolute((fnr - fpr)))]
print("EER: {}%".format(EER * 100))
plt.figure()
lw = 2
plt.plot(fpr, tpr, color='darkorange', lw=lw, label='ROC curve')
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()
def blca(datafile, numprocs):
#run c++ blocking routine, saves txt data file with blocking data
os.system("make --silent")
os.system("mpirun -n %i blocking.out 100 3000 2 %i %s" %
(nprocs, numprocs, datafile)) #VMC
#os.system("mpirun -n %i blocking.out 5000 100 20000 %i %s"%(nprocs,numprocs,datafile))#DMC
#read txt file and save plot
data = np.genfromtxt(fname=datafile + '.txt')
fig = plt.figure()
plt.plot(data[:, 0], data[:, 2], 'k+')
plt.xlabel(r'$\tau_{trial}$', size=20)
plt.ylabel(r'$\epsilon$', size=20)
plt.xlim(np.min(data[:, 0]), np.max(data[:, 0]))
plt.ylim(np.min(data[:, 2]), np.max(data[:, 2]))
fig.savefig(datafile + '.eps', format='eps')
#open plot if -p in argv
if plot_res:
os.system('evince %s%s ' % (datafile + '.eps', '&'))
print("plot saved : %s" % (datafile + '.eps'))
def visual_importnance(X, forest):
importances = forest.feature_importances_
std = np.std([tree.feature_importances_ for tree in forest.estimators_],
axis=0)
indices = np.argsort(importances)[::-1]
# Print the feature ranking
print("Feature ranking:")
for f in range(X.shape[1]):
print("%d. feature %d (%f)" % (f + 1, indices[f], importances[indices[f]]))
# Plot the feature importances of the forest
plt.figure()
plt.title("Feature importances")
plt.bar(range(X.shape[1]), importances[indices],
color="r", yerr=std[indices], align="center")
plt.xticks(range(X.shape[1]), indices)
plt.xlim([-1, X.shape[1]])
plt.show()
def RysujGeom(x_range, WEZLY, ELEMENTY, types):
plt.plot(x_range[0], 0, '*') #x_range[0]
plt.plot(x_range[1], 0, '*') #x_range[1]
plt.plot(x_range, [0, 0])
plt.plot(WEZLY, np.zeros(len(WEZLY)), '*')
plt.text(x_range[0] - 0.15, 0, types[0])
plt.text(x_range[1] + 0.15, 0, types[1])
for i in range(0, len(WEZLY)):
plt.text(WEZLY[i] - 0.03, 0.01, str(WEZLY[i]))
plt.text(WEZLY[i] - 0.05, -0.05, str(i + 1))
for i in range(0, len(WEZLY) - 1):
print((WEZLY[i] - WEZLY[i + 1]) / 2)
plt.text(WEZLY[i] / 2 + WEZLY[i + 1] / 2, 0.05, str(i + 1))
plt.xlim([x_range[0] - 0.3, x_range[1] + 0.3])
plt.ylim([-0.2, 0.42])
def plot_mean_vectors(data,
attribute,
start=WARMUP_PERIOD,
duration=SIM_TIME,
iterations=None):
if iterations is None:
iterations = [0]
sel = data[data.name == attribute]
# plot a mean vector for each iteration
for i in iterations:
tmp = sel[sel.run == i]
for row in tmp.itertuples():
plt.plot(row.time, running_avg(row.value))
plt.title("responseTime")
plt.xlim(start, duration)
plt.show()
return
def plot_trial_avg_data_with_stds(self, neuron_ind, var_level):
neuron_i_data_by_trial = self.by_trial_IT_Neural_Data_objmeans_sorted_by_category[var_level][:, :, neuron_ind]
neuron_i_data_trial_mean = neuron_i_data_by_trial.mean(1)
neuron_i_data_trial_std = neuron_i_data_by_trial.std(1)
minval = neuron_i_data_trial_mean.min()
maxval = neuron_i_data_trial_mean.max()
plt.plot(neuron_i_data_trial_mean)
plt.fill_between(np.arange(64), minval, maxval,
where=(np.arange(64) / 8) % 2, color='k', alpha=0.2)
plt.fill_between(np.arange(64),
neuron_i_data_trial_mean - neuron_i_data_trial_std,
neuron_i_data_trial_mean + neuron_i_data_trial_std,
color='b', alpha=0.2)
plt.xticks(np.arange(0, 64, 8) + 4, self.unique_categories, rotation=30);
plt.ylabel('Neural Responses')
plt.ylim(minval, maxval)
plt.title('Responses for neuron %d Variation %s images' % (neuron_ind, var_level))
plt.xlim(0, 64)
def plot_mean_vectors_datalink(data,
prefix,
start=0,
duration=SIM_TIME,
iterations=None,
datalinks=range(0, NUM_DATA_LINK)):
if iterations is None:
iterations = [0]
sel = data[data.name.str.startswith(prefix + '-')]
for d in datalinks:
usr = sel[sel.name == prefix + "-" + str(d)]
for i in iterations:
tmp = usr[(usr.run == i)]
for row in tmp.itertuples():
plt.plot(row.time, running_avg(row.value))
# plot the data
plt.xlim(start, duration)
plt.show()
return
def udaljenost_tocke(x1,y1,x2,y2,r):
plt.xlim([0,10])
plt.ylim([0,10])
kruznica = plt.Circle((x2,y2),r,color='r')
plt.gca().add_artist(kruznica)
plt.plot(x1,y1, 'bo')
x = (x1-x2)**2 + (y1-y2)**2
d = sqrt(x)
nacin = int(input('Unesi 1 za prikaz slike, 2 za spremanje'))
if znak ==1:
plt.show()
elif znak ==2:
naziv = input('Unesite naziv slike:')
plt.savefig(f'{naziv}.pdf')
epsilon = 0.01
if d < r:
print(f'Točka je unutar kružnice, a udaljenost je {d}.')
elif r-epsilon < d < r+epsilon:
print(f'Točka se nalazi na kružnici.')
else:
print(f'Točka je izvan kružnice, a udaljenost je {d}.')
def plot_board(self):
X = self.X
fig = plt.figure(figsize=(5, 5))
plt.xlim(-1, 1)
plt.ylim(-1, 1)
if self.mu and self.clusters:
mu = self.mu
clus = self.clusters
K = self.K
for m, clu in clus.items():
cs = cm.spectral(1. * m / self.K)
plt.plot(mu[m][0],
mu[m][1],
'o',
marker='*',
markersize=12,
color=cs)
plt.plot(zip(*clus[m])[0],
zip(*clus[m])[1],
'.',
markersize=8,
color=cs,
alpha=0.5)
else:
plt.plot(zip(*X)[0], zip(*X)[1], '.', alpha=0.5)
if self.method == '++':
tit = 'K-means++'
else:
tit = 'K-means with random initialization'
pars = 'N=%s, K=%s' % (str(self.N), str(self.K))
plt.title('\n'.join([pars, tit]), fontsize=16)
plt.savefig('kpp_N%s_K%s.png' % (str(self.N), str(self.K)),
bbox_inches='tight',
dpi=200)
def make_bar_graph(data=housing):
'''
:param data:
:return:
'''
data = data
mp.figure('Bar', facecolor='lightgray')
mp.title('Bar', fontsize=20)
gs = mg.GridSpec(3, 4)
i, j = 0, 0
for column in housing.columns:
# 创建子图
mp.subplot(gs[i, j])
# 在图形内部添加文字，设置位置，内容，对齐方式，字号，颜色，透明度
mp.text(0.5, 0.5, str(i) + '+' + str(j), ha='center', va='center', size=35, color='red', alpha=0.5)
# 删除边界刻度
mp.xticks(())
mp.yticks(())
# 绘制柱状图
single_data = housing[column]
min_data, max_data = min(single_data), max(single_data)
mp.xlim(min(min_data, max_data))
step = (max_data - min_data) / 10
for x in range(min_data, max_data, step):
sum_num = sum(x <= single_data <= x + step)
y.append(sum_num)
x = np.range(len(y))
mp.bar(x, y, 0.4, color='dodgerblue', label=column, alpha=0.75)
# 调整子图位置
j += 1
j = j % 4
i = i + j // 4
# 改变布局形式，改为紧凑布局
mp.tight_layout()
pass
def show_perceptron(X, Y, w, b):
"""Present the current state of the perceptron algorithm
where X (sequence of sequences) isthe data
Y - the labels
w - the candidate seperator
b- the seprator bias
Works only for 2D data - X assumed to be sequence of sequences of size 2
"""
if len(X) != 2 or len(Y) != 2 or len(w) != 2:
print("Works only for 2d data!")
return
X = np.array(X)
Y = np.array(Y)
w = np.array(w)
ploty.plot(X[Y == 1, 0],
X[Y == 1, 1],
'bD',
markersize=10,
linestyle='None',
linewidth=3)
ploty.plot(X[Y == -1, 0],
X[Y == -1, 1],
'ro',
markersize=10,
linestyle='None',
linewidth=3)
minx = min(X[:, 0]) - abs(min(X[:, 0])) * 0.2
maxx = max(X[:, 0]) + abs(max(X[:, 0])) * 0.2
miny = min(X[:, 1]) - abs(min(X[:, 1])) * 0.2
maxy = max(X[:, 1]) + abs(max(X[:, 1])) * 0.2
ploty.xlim([minx, maxx])
ploty.ylim([miny, maxy])
A = np.arange(minx, maxx, 0.01)
if w[0] == 0 and w[1] == 0:
ploty.plot(0, b, '.k', linewidth=2)
ploty.xlim(min(minx, -0.1), max(maxx, 0.1))
ploty.ylim(min(miny, b - 0.1), max(maxy, b + 0.1))
elif w[1] == 0:
B = np.arange(miny - abs(miny) * 0.2, maxy + abs(maxy) * 0.2, 0.01)
b = b / w[0]
ploty.plot([b] * len(B), B, 'k', linewidth=2)
ploty.xlim(min(minx, b - 0.1), max(maxx, b + 0.1))
else:
l = b / w[1] - (w[0] / w[1]) * A
ploty.plot(A, l, 'k', linewidth=2)
ploty.ylim(min(miny, min(l)), max(maxy, max(l)))
ploty.show()
diabetes_y_train = diabetes.target[:-20]
diabetes_y_test = diabetes.target[-20:]
regr = linear_model.LinearRegression()
regr.fit(diabetes_X_train, diabetes_y_train)
# >> LinearRegression(copy_X=True, fit_intercept=True, normalize=False)
print regr.coef_
# The mean square error
np.mean((regr.predict(diabetes_X_test)-diabetes_y_test)**2)
# Explained variance score: 1 is perfect prediction
# and 0 means that there is no linear relationship
# between X and Y.
regr.score(diabetes_X_test, diabetes_y_test)
# Plot results
pl.clf() # Clear plots
pl.plot(diabetes_X_test, regr.fit(diabetes_X_train, diabetes_y_train));
pl.title('Linear regression of sample diabetes data\n'
'Centroids are marked with white cross')
pl.xlim(x_min, x_max)
pl.ylim(y_min, y_max)
pl.xticks(())
pl.yticks(())
pl.show()
def plotFeatureArrays(featureVecs,
array_shape,
n_figs=10,
tiled=True,
tiles_shape=(2, 5),
tile_psn=(.1, .125, .4, .4),
xlims=None,
ylims=None,
titles=None,
xlabel=None,
ylabel=None,
noise_floor=None,
extent=None,
origin=None,
colorbar=True):
n_samples = featureVecs.shape[0]
if tiled:
sample_idxs = np.array(random.sample(range(n_samples)),
np.prod(tiles_shape)).reshape(tiles_shape)
plt.figure()
for r in range(tiles_shape[0]):
for c in range(tiles_shape[1]):
idx = sample_idxs[r, c]
arr = featureVecs[idx, :].reshape(array_shape)
# set signal limits
maxSig = arr.max()
if noise_floor is not None:
minSig = magSig - noise_floor
arr[arr < minSig] = minSig
minSig = arr.min()
left = tile_psn[0] * (c + 1) + tile_psn[2] * c
bottom = tile_psn[1] * (r + 1) + tile_psn[3] * r
plt.axes((left, bottom, tile_psn[2], tile_psn[3]))
plt.imshow(arr,
extent=extent,
aspect='auto',
interpolation='nearest',
origin=origin,
cmap='binary',
vmin=minSig,
vmax=maxSig)
if colorbar:
plt.colorbar()
if xlims is not None:
plt.xlim(xlims)
if ylims is not None:
plt.ylim(ylims)
if xlabel is not None and r == 0:
plt.xlabel(xlabel)
else:
plt.xticks([])
if ylabel is not None and c == 0:
plt.ylabel(ylabel)
else:
plt.yticks([])
if titles is not None:
plt.title(title[idx])
plt.show()
else:
sample_idxs = np.array(random.sample(range(n_samples)), n_figs)
for idx in sample_idxs:
arr = featureVecs[idx, :].reshape(array_shape)
# set signal limits
maxSig = arr.max()
if noise_floor is not None:
minSig = magSig - noise_floor
arr[arr < minSig] = minSig
minSig = arr.min()
plt.figure()
plt.axes(tile_psn)
plt.imshow(arr,
extent=extent,
aspect='auto',
interpolation='nearest',
origin=origin,
cmap='binary',
vmin=minSig,
vmax=maxSig)
if colorbar:
plt.colorbar()
if xlims is not None:
plt.xlim(xlims)
if ylims is not None:
plt.ylim(ylims)
if xlabel is not None and r == 0:
plt.xlabel(xlabel)
else:
plt.xticks([])
if ylabel is not None and c == 0:
plt.ylabel(ylabel)
else:
plt.yticks([])
if titles is not None:
plt.title(title[idx])
plt.show()
def create_figure_surface(figid, aspect, xx, yy, cmin, cmax, levels, slices, v3d):
''' creates a plot of the surface of a tracer data
Parameters
----------
figid : int
id of figure
aspect: float
aspect ratio of figure
xx : array
scale of x axis
yy : array
scale of y axis
cmin,cmax : array
minimum and maxminm of the color range
levels : array
range of contourlines
slices : array
location of slices
v3d : vector data in geometry format
Returns
-------
plot : of surface data
'''
# prepare matplotlib
import matplotlib
matplotlib.rc("font",**{"family":"sans-serif"})
matplotlib.rc("text", usetex=True)
#matplotlib.use("PDF")
import matplotlib.pyplot as plt
# basemap
from mpl_toolkits.basemap import Basemap
# numpy
import numpy as np
# data
vv = v3d[0,:,:,0]
# shift
vv = np.roll(vv, 64, axis=1)
# plot surface
plt.figure(figid)
# colormap
cmap = plt.cm.bone_r
# contour fill
p1 = plt.contourf(xx, yy, vv, cmap=cmap, levels=levels, origin="lower")#, hold="on")
plt.clim(cmin, cmax)
# contour lines
p2 = plt.contour(xx, yy, vv, levels=levels, linewidths = (1,), colors="k")#, hold="on")
plt.clabel(p2, fmt = "%2.1f", colors = "k", fontsize = 14)
#plt.colorbar(p2,shrink=0.8, extend='both')
# slices
#s1 = xx[np.mod(slices[0]+64, 128)]
#s2 = xx[np.mod(slices[1]+64, 128)]
#s3 = xx[np.mod(slices[2]+64, 128)]
# print s1, s2, s3
#plt.vlines([s1, s2, s3], -90, 90, color='k', linestyles='--')
# set aspect ratio of axes
plt.gca().set_aspect(aspect)
# basemap
m = Basemap(projection="cyl")
m.drawcoastlines(linewidth = 0.5)
# xticks
plt.xticks(range(-180, 181, 45), range(-180, 181, 45))
plt.xlim([-180, 180])
plt.xlabel("Longitude [degrees]", labelpad=8)
# yticks
plt.yticks(range(-90, 91, 30), range(-90, 91, 30))
plt.ylim([-90, 90])
plt.ylabel("Latitude [degrees]")
# write to file
plt.savefig("solution-surface", bbox_inches="tight")
plt.show()
else: # violated
self.pt_test.set_color('r')
# n_prev@(xp-xp)<=b ->>> penality <= 0
obs_con_penality= ds
self.txt3.set_text('n_prev@(xp-xp)-b = %1.2f' % (obs_con_penality))
center = np.array([0.1,-0.15,0.])
widths_vec = np.ones(3)
obs = PolygonalObstacle(center, widths_vec)
fig, ax = plt.subplots()
plot_rectangle(ax, center[idx], widths_vec[idx])
plt.xlim([-1.5*widths_vec[idx[0]],2.5*widths_vec[idx[0]]])
plt.ylim([-1.5*widths_vec[idx[1]],2.5*widths_vec[idx[1]]])
if idx[0] == 0:
plt.xlabel('x')
elif idx[0] == 1:
plt.xlabel('y')
else:
plt.xlabel('z')
if idx[1] == 0:
plt.ylabel('x')
elif idx[1] == 1:
plt.ylabel('y')
else:
plt.ylabel('z')
print (dado)
# In[4]:
date = pd.date_range('1998-01-01','2019-05-01', freq = 'M').strftime('%m-%Y')
# In[5]:
plt.figure(figsize = (25,12))
plt.plot (pr,'-b')
plt.xticks(range(0, pr.size, 4), date[::4], rotation = 60)
plt.xlim([range(0, pr.size)[0],range(0, pr.size)[-1]])
# #### b) Quais os problemas que voce indentificou na apresentação do seu dado. Como o gráfico poderia ter sua apresentação melhorada?
# In[6]:
str = 'o gráfico fica poluido, poderia melhorar trabalhando um intervalo maior'
# #### 2) Com o mesmo arquivo, calcule a média de precipitação para cada ano. Construa um gráfico de barras com a média de cada ano.
# In[7]:
x_set, y_set = train_x, train_y
X1, X2 = np.meshgrid(
np.arange(start=x_set[:, 0].min() - 1,
stop=x_set[:, 0].max() + 1,
step=0.01),
np.arange(start=x_set[:, 1].min() - 1,
stop=x_set[:, 1].max() + 1,
step=0.01))
plt.countourf(
X1,
X2,
cls_svc.predict(np.array([X1.ravel, X2.ravel()]).T).reshape(X1.shape),
alpha=0.75,
cmap=ListedColormap(("red", "green"))
) ###### countourf- logistic regression ne devide kare && ravel--- midpoint kadhwa
plt.xlim(X1.min(), X1.max()) #### limit banavi
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
plt.scatter(x_set[y_set == j, 0],
x_set[y_set == j, 1],
c=ListedColormap(('red', 'green'))(i),
label=j)
plt.title("SVM training set")
plt.xlabel("age")
plt.ylabel("estimated salary")
plt.legend()
plt.show()
######### plotting testing setsss
# In[90]:
fig = plt.figure()
nPC = range(1, maxNumPC + 1)
maker = ['x', 's', '^', '+', 'o', 'D']
for i in [5, 2, 4, 3, 1, 0]:
expt, m, p = exptList[i]
plt.semilogy(accList[expt],
timeList[expt],
'-' + maker[2 * m + p],
label="{} {}".format(modelList[m], policyList[p]))
plt.ylabel("Time in second")
plt.xlabel("Accuracy (%)")
plt.title("Accuracy vs time for different classifiers")
plt.xlim([0, 100])
plt.grid("on")
plt.legend(loc="best")
fig.set_size_inches(10, 6)
fName = os.path.join(pDir, 'accuracy_time_n{}_{}.png'.format(n, rev))
savefig(fName, bbox_inches='tight')
plt.show()
# In[83]:
fig = plt.figure()
nPC = range(1, maxNumPC + 1)
maker = ['x', 's', '^', '+', 'o', 'D']
for i in [5, 2, 4, 3, 1, 0]:
expt, m, p = exptList[i]
plt.semilogy(accList[expt],
# -*- coding: utf-8 -*-
"""
Created on Mon Jan 23 11:07:06 2017
@author: Paige
"""
import matplotlib as plt
import numpy as np
x = np.linspace(-10, 10, 400)
cos = np.cos(x)
sin = np.sin(x)
plt.plot(x, cos, "r", label="cos(x)") # r for red line
plt.plot(x, sin, "b--", label="sin(x)") # b-- for blue dashed line
# colors include red(r), green(g), yellow(y), blue(b), cyan(c),
# magenta(m), black(k), white(w)
# line styles include solid line("-"), dashed line("--"),
# solid line("-"), square("s"), dots("o"), smaller dots(".")
plt.xlim(-10, 10)
plt.legend()
plt.xlabel("x")
plt.title("Trigonometric Functions")
plt.ylabel("cos(x) or sin(x)")
# plt.savefig("1-23-2017.png")
plt.show()
model.predict(X0[:1]),
marker='o',
s=300,
c='r',
lw=5,
alpha=0.5)
plt.plot(xx, model.predict(xx[:, np.newaxis]) > 0.5, lw=2)
plt.scatter(X0[0],
model.predict_proba(X0[:1])[0][1],
marker='x',
s=300,
c='r',
lw=5,
alpha=0.5)
plt.axvline(X0[0], c='r', lw=2, alpha=0.5)
plt.xlim(-3, 3)
plt.subplot(212)
plt.bar(model.classes_, model.predict_proba(X0[:1])[0], align="center")
plt.xlim(-1, 2)
plt.gca().xaxis.grid(False)
plt.xticks(model.classes_)
plt.title("conditional probability")
plt.tight_layout()
plt.show()
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.cross_validation import train_test_split
iris = load_iris()
X = iris.data[:, [2, 3]]
y = iris.target
corr_coef = numpy.corrcoef(numpy.array(fc),numpy.array(fc2))[0][1] # this is R
line_x = numpy.linspace(numpy.array(fc).min(),numpy.array(fc).max()) # this is to have some points to actually draw the line.
plots=[]
for i,classe in enumerate(all_classes):
a=plt.plot(numpy.array(fc)[all_classes[classe]],numpy.array(fc2)[all_classes[classe]],'o',alpha=.5, color=colors[i], marker=markers[i], label=classe)
plots.append(a)
plots.append( plt.plot(line_x, line_x*lin_fit[0] + lin_fit[1] , '--b', label='$R^2$ = %.2f'%(corr_coef*corr_coef) )) #we append the plot of the line here
kwarg={'size':6 }
plt.legend(loc='upper right', prop=kwarg)
if log2gene1:
plt.xscale('log', basex=2)
plt.xlabel('log2 expression of %s'%in_gene)
plt.xlim(xmax=plt.xlim()[1]+2^10) #make room for the legend
else:
plt.xlabel('%s'%in_gene)
plt.xlim(xmax=plt.xlim()[1]+1000) #make room for the legend
if log2gene2:
plt.yscale('log', basey=2)
plt.ylabel('log2 expression of %s'%in_gene2)
plt.xlim(xmax=plt.xlim()[1]+2^10) #make room for the legend
else:
plt.xlabel('%s'%in_gene)
plt.xlim(xmax=plt.xlim()[1]+1000) #make room for the legend
totalhist += hist
f.close()
print totalhist
ax.plot(10 ** binmids, totalhist, color=colors[i], linewidth=1.5, alpha=0.8)
ax.set_yscale("log")
ax.set_xscale("log")
ax.set_xlim(5.0e18, 1.0e24)
ax.set_ylim(1, 1.0e5)
set_ticks(ax, "0.6")
ax.xaxis.grid(False, which="minor")
ax.yaxis.grid(False, which="minor")
plotlim = mpl.xlim() + mpl.ylim()
print plotlim
ax.imshow([0, 0], [1, 1], cmap=mp.cm.Grays, interpolation="bicubic", extent=plotlim)
ax.set_xlabel(r"surface density / $\mathdefault{cm^{-2}}$", fontproperties=tfm, size=15)
# ax.set_ylabel('d', fontproperties = tfm, size = 15)
ax.set_ylabel(r"volume weighted PDF", fontproperties=tfm, size=15)
(time, unit_t) = get_time(infoname)
timeMyr = time * unit_t / 31557600.0 / 1.0e6
horiz = 5.0e22
vert = 2.0e4
ax.text(
horiz,
vert,
r"%.1f" % timeMyr,
# In[15]:
X_set, Y_set = x_test, y_test
X1, X2 = np.meshgrid(
np.arange(start=X_set[:, 0].min() - 1,
stop=X_set[:, 0].max() + 1,
step=0.01),
np.arange(start=X_set[:, 1].min() - 1,
stop=X_set[:, 1].max() + 1,
step=0.01))
plt.contourf(X1,
X2,
classifier.predict(np.array([X1.ravel(),
X2.ravel()]).T).reshape(X1.shape),
alpha=0.75,
cmap=ListedColormap(('cyan', 'yellow', 'blue')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(Y_set)):
plt.scatter(X_set[Y_set == j, 0],
X_set[Y_set == j, 1],
c=ListedColormap(('red', 'green', 'yellow'))(i),
label=j)
plt.title('Logistic Regression (Training set)')
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.legend()
plt.show()
# In[ ]:
plots=[]
for i,classe in enumerate(classes2use):
a=plt.plot(numpy.array(fc)[classes2use[classe]],numpy.array(fc2)[classes2use[classe]],'o',alpha=.5, color=py_colors[i], marker=markers[i], label=classe)
plots.append(a)
if not log2gene1 and not log2gene2:
plots.append( plt.plot(line_x, line_x*lin_fit[0] + lin_fit[1] , '--b', label='$R^2$ = %.2f'%(corr_coef*corr_coef) )) #we append the plot of the line here
kwarg={'size':6 }
plt.legend(loc='upper right', prop=kwarg)
if log2gene1:
plt.xscale('log', basex=2)
plt.xlabel('Expression (log2) %s'%in_gene)
plt.xlim(xmax=plt.xlim()[1]*1.1)
else:
plt.xlabel('%s'%in_gene)
plt.xlim(xmax=plt.xlim()[1]*1.05) #make room for the legend
if log2gene2:
plt.yscale('log', basey=2)
plt.ylabel('Expression (log2) %s'%in_gene2)
plt.ylim(ymax=plt.ylim()[1]*1.1) #make room for the legend
else:
plt.ylabel('%s'%in_gene2)
plt.ylim(ymax=plt.ylim()[1]*1.05) #make room for the legend
args=(ws, fs, model, tq_interpol))
#if not load:
#sampler.run_mcmc(pos, 15000, progress = True)
#tau = sampler.get_autocorr_time()
#print('autocorr',tau)
#flattens the data according to burning/thinning from autocorrelation time
#flat_samples = sampler.get_chain(discard=1000, thin=1, flat=True)
#np.save('tq_{1}_samples_{0}.npy'.format(stack, bin_size),flat_samples)
#else:
#flat_samples = np.load('tq_{1}_samples_{0}.npy'.format(stack, bin_size))
cv = lambda z: (1 / 2) * (1 + scipy.special.erf(z / np.sqrt(2)))
plt.figure()
plt.plot(tq_fine, pdf)
plt.xlim(quantile(cv(-4)), quantile(cv(4)))
plt.xlabel("$\\log_{10}(t_Q)$ (years)")
plt.ylabel("Probability Density")
tqmed = quantile(0.5)
one_sig_upper = quantile(cv(1))
one_sig_lower = quantile(cv(-1))
two_sig_upper = quantile(cv(2))
two_sig_lower = quantile(cv(-2))
plt.axvline(x=one_sig_upper, color='red', linestyle='--')
plt.axvline(x=one_sig_lower, color='red', linestyle='--')
plt.axvline(x=two_sig_upper, color='blue', linestyle='--')
plt.axvline(x=two_sig_lower, color='blue', linestyle='--')
plt.axvline(x=tqmed, color='orange', linestyle='--')
### simulation
n_range = range(1, 5001)
lower_bounds = []
upper_bounds = []
for n in n_range:
lower_bound, upper_bound = get_boundary(n)
lower_bounds.append(lower_bound / n)
upper_bounds.append(upper_bound / n)
plt.style.use('seaborn-notebook')
plt.plot(n_range, lower_bounds, label='lower_bounds\ndivided by n')
plt.plot(n_range, upper_bounds, label='upper_bounds\ndivided by n')
#plt.axvline(x=1000, color = 'red', linestyle = '--')
plt.legend(prop={'size': 13})
plt.xlim(1, 5000)
plt.xlabel("dimensions")
plt.title("Ratio between 2-standard devation boundaries and n as n increases",
fontdict={'fontsize': 16})
plt.show()
#### how many points lie in the 10% period or outside
def get_pct_for_interval(n):
sample = np.random.normal(size=(N, n))
dist = np.square(np.linalg.norm(sample, axis=1))
lower_interval = np.count_nonzero(dist < n * 0.95)
middle_interval = np.count_nonzero((dist >= n * 0.95) & (dist <= n * 1.05))
large_interval = np.count_nonzero(dist > n * 1.05)
def LoadAndPlot(num_epochs, num_values, num_experiments):
import numpy as np
import matplotlib as plt
import matplotlib
matplotlib.use('Agg')
# matplotlib.use('Agg')plt.switch_backend('Agg')
# plt.switch_backend('Agg')
import matplotlib.pyplot as plt
output_tr = np.fromfile('./output/output_tr',
sep="").reshape(num_experiments, num_values + 1, 2)
output_sg = np.fromfile('./output/output_sg',
sep="").reshape(num_experiments, num_values + 1, 2)
output_sga = np.fromfile('./output/output_sga',
sep="").reshape(num_experiments, num_values + 1,
2)
parameters_tr = np.fromfile('./output/parameters_tr', sep="")
parameters_sg = np.fromfile('./output/parameters_sg', sep="")
parameters_sga = np.fromfile('./output/parameters_sga', sep="")
print 'This is the parameters or TRish'
print parameters_tr
print 'This is the parameters or SG'
print parameters_sg
print 'This is the parameters or SG Adaptive'
print parameters_sga
# print 'output'
# print output_tr
avg_output_tr = output_tr.mean(axis=0)
avg_output_sg = output_sg.mean(axis=0)
avg_output_sga = output_sga.mean(axis=0)
sg_loss = np.trim_zeros(avg_output_sg[:, 0])
sg_acc = np.trim_zeros(avg_output_sg[:, 1])
x = np.arange(len(sg_acc)) / (1.0 * len(sg_acc)) * num_epochs
# print 'average_output'
# print avg_output_tr
str_loss = np.trim_zeros(avg_output_tr[:, 0])
str_acc = np.trim_zeros(avg_output_tr[:, 1])
sga_loss = np.trim_zeros(avg_output_sga[:, 0])
sga_acc = np.trim_zeros(avg_output_sga[:, 1])
string_acc = "./figures/Mnist_testing_acc_{}epoch_avg.png".format(
num_epochs)
string_acc_multi = "./figures/Mnist_testing_acc_{}epoch_3alg.png".format(
num_epochs)
string_loss = "./figures/Mnist_training_loss_{}epoch_avg.png".format(
num_epochs)
string_loss_multi = "./figures/Mnist_training_loss_{}epoch_3alg.png".format(
num_epochs)
plt.figure(0)
plt.plot(x[10:-1], str_acc[10:-1], 'b-', x[10:-1], sg_acc[10:-1], 'r-',
sga_acc[10:-1], 'k-')
plt.legend(['TRish', 'SG', 'SGA'], loc='lower right')
plt.ylabel('Testing accuracy')
plt.xlabel('Epochs')
plt.xlim(0, float(num_epochs))
plt.savefig(string_acc)
plt.close()
plt.figure(1)
plt.plot(x[10:-1], str_loss[10:-1], 'b-', x[10:-1], sg_loss[10:-1], 'r-',
sga_loss[10:-1], 'k-')
#plt.plot(x,str_acc_mask ,'r-',x, sg_acc_mask,'b-')
#plt.plot(x,str_acc ,'r-',x, sg_acc,'b-')
#plt.legend(['SG', 'TRish'], loc='upper right')
plt.legend(['TRish', 'SG', 'SGA'], loc='upper right')
plt.ylabel('Training loss')
plt.xlabel('Epochs')
plt.xlim(0, float(num_epochs))
plt.savefig(string_loss)
plt.close()
plt.figure(2)
# plt.plot(x[10:-1], str_acc[10:-1],'b-',x[10:-1], sg_acc[10:-1],'r-')
for i in range(num_experiments):
plt.plot(x[10:100], output_tr[i, 10:-1, 0], 'b-')
plt.plot(x[10:100], output_sg[i, 10:-1, 0], 'r-')
plt.plot(x[10:100], output_sga[i, 10:-1, 0], 'k-')
plt.legend(['TRish', 'SG', 'SGA'], loc='upper right')
plt.ylabel('Training Loss')
plt.xlabel('Epochs')
plt.xlim(0, float(num_epochs))
plt.savefig(string_loss_multi)
plt.show()
plt.figure(3)
# plt.plot(x[10:-1], str_acc[10:-1],'b-',x[10:-1], sg_acc[10:-1],'r-')
for i in range(num_experiments):
plt.plot(x[10:100], output_tr[i, 10:-1, 1], 'b-')
plt.plot(x[10:100], output_sg[i, 10:-1, 1], 'r-')
plt.plot(x[10:100], output_sga[i, 10:-1, 1], 'k-')
# plt.plot(x[10:100], output_tr[0,10:-1,0],'b-',x[10:100], output_tr[1,10:-1,0],'b-',
# x[10:100], output_tr[2,10:-1,0],'b-')
plt.legend(['TRish', 'SG', 'SGA'], loc='lower right')
plt.ylabel('Testing accuracy')
plt.xlabel('Epochs')
plt.xlim(0, float(num_epochs))
plt.savefig(string_acc_multi)
plt.show()
# print avg_output_tr[avg_output_tr!=0]
# output_tune_tr = np.fromfile('./output/tune_trish',sep="").reshape(2,16,2)
# parameters_tune = np.fromfile('./output/tune_trish_param',sep="")
# output_tune_sg = np.fromfile('./output/tune_sg',sep="").reshape(2,16,2)
# parameters_tune_sg = np.fromfile('./output/tune_sg_param',sep="")
# print output_tune_tr
# print parameters_tune
# print output_tune_sg
# print parameters_tune_sg
Y = list(data_subset[to_plot])
Y_err = [0] * len(Y)
# Y_err = list(data_subset[to_plot + '_std'])
# plt.errorbar(T[:], Y[:], yerr = Y_err, markersize = 5, marker = 'o', label = type)
plt.plot(T[3:], Y[3:], markersize = 5, lw = 3, marker = 'o', label = type[4:-8] + ' spins')
# if i == 0:
# plt.plot(T[:], Y[:], markersize = 5, lw = 3, marker = 'o', label = '1D')
# elif i == 1 :
# plt.plot(T[1:], Y[1:], markersize = 5, lw = 3, marker = 'o', label = '1.5D')
# elif i == 2 :
# plt.plot(T[1:], Y[1:], markersize = 5, lw = 3, marker = 'o', label = '2D')
# else:
# plot(T[7:], Y[7:], markersize = 5, lw = 3, marker = 'o', label = '2.5D')
plt.xlabel('$T$', fontsize = 20)
plt.ylabel('$E$', fontsize = 20, rotation = 'horizontal', labelpad = 25)
#plt.axvline(x = 2.2, lw = 5, color = 'k', alpha = 0.2)
plt.subplots_adjust(left = 0.15, right = 0.92, top = 0.92, bottom = 0.15)
plt.tick_params(axis = 'both', which = 'major', labelsize = 20)
plt.xlim(left = 0, right = 5)
plt.ylim(bottom = -2.1, top = 0)
legend = plt.legend(fontsize = 18, loc = 2)
show()
''.format(roc_auc["macro"]),
color='navy',
linestyle=':',
linewidth=4)
colors = cycle(['aqua', 'darkorange', 'cornflowerblue'])
for i, color in zip(range(2), colors):
plt.plot(fpr[i],
tpr[i],
color=color,
lw=2,
label='ROC curve of class {0} (area = {1:0.2f})'
''.format(i, roc_auc[i]))
plt.plot([0, 1], [0, 1], 'k--', lw=2)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Some extension of Receiver operating characteristic to multi-class')
plt.legend(loc="lower right")
plt.show()
#%%
prediction2 = model.predict_classes(data3)
from sklearn.metrics import classification_report, confusion_matrix
print('Confusion Matrix')
print(confusion_matrix(labels2, prediction2))
print('Classification Report')
target_names = ['Benign', 'Malignant']
fontsize=18, color=colors[-1])
# fine tune
if cosmology == "FLCDM":
title = r"$H_{\rm{0}} \rm{[0, 150]} \ \ \ \Omega _{\rm{m}} \rm{[0.05, 0.5]}$"
elif cosmology == "FwCDM":
title = r"$H_{\rm{0}} \rm{[0, 150]} \ \ \ \Omega _{\rm{m}} \rm{[0.05, 0.5]} \ \ \ w \rm{[-2.5, 0.5]}$"
elif cosmology == "oLCDM":
title = r"$H_{\rm{0}} \rm{[0, 150]} \ \ \ \Omega _{\rm{m}} \rm{[0.05, 0.5]} \ \ \ \Omega _{\rm{k}} \rm{[-0.5, 0.5]}$"
plt.title(title, fontsize=18)
plt.xlabel(r"$H_{\rm{0}}\rm{\ [km\,s^{-1}\,Mpc^{-1}]}$", fontsize=24)
plt.ylabel("probability density", fontsize=18)
plt.yticks(fontsize=14)
plt.xticks(fontsize=20)
plt.yticks([])
legend = plt.legend()
legend.get_frame().set_alpha(0.0)
if cosmology in ["FLCDM", "oLCDM"]:
plt.xlim([48, 99])
plt.ylim([max(h)*0.005, max(h)*1.1])
elif cosmology == "FwCDM":
plt.xlim([48, 109])
plt.ylim([max(h)*0.005, max(h)*2.2])
plt.tight_layout()
plt.savefig(os.path.join(savedir, "H0.png"))
plt.show()
def plot_activities(person):
'''
Plot a high level activity plan for a single person
'''
#Load a df with a persons activty plan
activities, start_times, end_times, durations = [], [], [], []
for component in person.plan.day:
activities.append(component.act.title())
start_times.append(component.start_time.hour +
component.start_time.minute / 60)
end_times.append(component.end_time.hour +
component.end_time.minute / 60)
durations.append(component.duration.total_seconds() / 3600)
df = pd.DataFrame(zip(activities, start_times, durations),
columns=['act', 'start_time', 'dur'])
#Define a colour map for a unique list of activities
colors = plt.cm.tab10.colors
activities_unique = df['act'].unique()
d_color = dict(zip(activities_unique, colors))
df['color'] = df['act'].map(d_color)
#Plotting
fig, ax = plt.subplots(figsize=(16, 4))
label_x, label_y = [], []
for i in range(len(df)):
y = 1
data = df.iloc[i]
ax.barh(y,
width='dur',
data=data,
left='start_time',
label='act',
color='color')
#Populate Labelling Params
label_x.append(data['start_time'] + data['dur'] / 2)
label_y.append(y)
#Labels
rects = ax.patches
for x, y, rect, activity in zip(label_x, label_y, rects, activities):
if rect.get_width() >= 3:
ax.text(x,
y,
activity,
ha='center',
fontdict={
'color': 'white',
'size': 14,
'weight': 'bold'
})
plt.xticks(range(25))
plt.xlim(right=24)
ax.get_yaxis().set_visible(False)
im = plt.imread('chicago.png')
implot = plt.imshow(im)
x = (df['west'] - df['west'].min())*477/(df['east'].max() - df['west'].min())
y = 798-(df['north'] - df['south'].min())*798/(df['north'].max() - df['south'].min())
s = df['currentspeed'] / df['currentspeed'].max()
plt.scatter(x,y,c=s,linewidth=0,s=1000,alpha=0.1)
#x0 = (df.ix[0]['west'] - df['west'].min())*477/(df['east'].max() - df['west'].min())
#y0 = 798-(df.ix[0]['north'] - df['south'].min())*798/(df['north'].max() - df['south'].min())
#plt.scatter(x0,y0,c='r',s=2000)
#x0 = (df.ix[0]['east'] - df['west'].min())*477/(df['east'].max() - df['west'].min())
#y0 = 798-(df.ix[0]['south'] - df['south'].min())*798/(df['north'].max() - df['south'].min())
#plt.scatter(x0,y0,c='r',s=2000)
plt.xlim(0,477)
plt.ylim(798,0)
plt.xticks([])
plt.yticks([])
#plt.plot([df['west'],df['west'],df['east'],df['east'],df['west']],[df['south'],df['north'],df['north'],df['south'],df['south']],linewidth=20,alpha=0.2)
# <codecell>
plt.figure(figsize=(15,15))
patches = []
verts = [(df['west'],df['south']),
(df['west'],df['north']),
(df['east'],df['north']),
(df['east'],df['south']),
(df['west'],df['south'])]
