def on_train_begin(self, logs={}):
sns.set_style("whitegrid")
sns.set_style("whitegrid", {"grid.linewidth": 0.5,
"lines.linewidth": 0.5,
"axes.linewidth": 0.5})
flatui = ["#9b59b6", "#3498db", "#95a5a6", "#e74c3c", "#34495e",
"#2ecc71"]
sns.set_palette(sns.color_palette(flatui))
# flatui = ["#9b59b6", "#3498db", "#95a5a6", "#e74c3c", "#34495e", "#2ecc71"]
# sns.set_palette(sns.color_palette("Set2", 10))
plt.ion() # set plot to animated
self.fig = plt.figure(
figsize=(self.width * (1 + len(self.get_metrics(logs))),
self.height)) # width, height in inches
# move it to the upper left corner
move_figure(self.fig, 25, 25)
python类set_palette()的实例源码
def scoped_mpl_import():
import matplotlib
matplotlib.rcParams['backend'] = MPL_BACKEND
import matplotlib.pyplot as plt
plt.rcParams['toolbar'] = 'None' # mute matplotlib toolbar
import seaborn as sns
sns.set(style="whitegrid", color_codes=True, font_scale=1.0,
rc={'lines.linewidth': 1.0,
'backend': matplotlib.rcParams['backend']})
palette = sns.color_palette("Blues_d")
palette.reverse()
sns.set_palette(palette)
return (matplotlib, plt, sns)
def set_styling():
sb.set_style("white")
red = colors.hex2color("#bb3f3f")
blue = colors.hex2color("#5a86ad")
deep_colors = sb.color_palette("deep")
green = deep_colors[1]
custom_palette = [red, blue, green]
custom_palette.extend(deep_colors[3:])
sb.set_palette(custom_palette)
mpl.rcParams.update({"figure.figsize": np.array([6, 6]),
"legend.fontsize": 12,
"font.size": 16,
"axes.labelsize": 16,
"axes.labelweight": "bold",
"xtick.labelsize": 16,
"ytick.labelsize": 16})
def makeDishwasherFig(ax=None, zNorm=True, save=True):
# ts = getGoodDishwasherTs()
# ts.data = ar.zNormalizeCols(ts.data)
ts = getFig1Ts(zNorm=True, whichTs=WHICH_DISHWASHER_TS)
# ax = ts.plot(useWhichLabels=['ZC'], showLabels=False, capYLim=900)
colors = DISHWASHER_COLOR_PALETTE * 3 # cycles thru almost three times
colors[DISHWASHER_DIM_TO_HIGHLIGHT] = DISHWASHER_HIGHLIGHT_COLOR
colors = colors[:ts.data.shape[1]]
ts.data[:, 2] /= 2 # scale the ugliest dim to make pic prettier
ax = ts.plot(showLabels=False, showBounds=False, capYLim=900, ax=ax,
colors=colors) # resets palette...
# ax = ts.plot(showLabels=False, showBounds=False, capYLim=900, ax=None) # works
# ax.plot(ts.data[:, DISHWASHER_DIM_TO_HIGHLIGHT], color=DISHWASHER_HIGHLIGHT_COLOR)
# sb.set_palette(DEFAULT_SB_PALETTE)
sb.despine(left=True)
ax.set_title("Dishwasher", y=TITLE_Y_POS)
# ax.set_xlabel("Minute")
plt.tight_layout()
if save:
saveFigWithName('dishwasher')
# ------------------------------------------------ MSRC
def reset_plt(self):
""" Reset the current matplotlib plot style. """
import matplotlib.pyplot as plt
plt.gcf().subplots_adjust(bottom=0.15)
if Settings()["report/xkcd_like_plots"]:
import seaborn as sns
sns.reset_defaults()
mpl.use("agg")
plt.xkcd()
else:
import seaborn as sns
sns.reset_defaults()
sns.set_style("darkgrid")
sns.set_palette(sns.color_palette("muted"))
mpl.use("agg")
def setupPalette(count, pal=None):
# See http://xkcd.com/color/rgb/. These were chosen to be different "enough".
colors = ['grass green', 'canary yellow', 'dirty pink', 'azure', 'tangerine', 'strawberry',
'yellowish green', 'gold', 'sea blue', 'lavender', 'orange brown', 'turquoise',
'royal blue', 'cranberry', 'pea green', 'vermillion', 'sandy yellow', 'greyish brown',
'magenta', 'silver', 'ivory', 'carolina blue', 'very light brown']
palette = sns.color_palette(palette=pal, n_colors=count) if pal else sns.xkcd_palette(colors)
sns.set_palette(palette, n_colors=count)
# For publications, call setupPlot("paper", font_scale=1.5)
def plot_example(missed, acknowledged):
sensor_miss = import_sensorfile(missed)
sensor_ack = import_sensorfile(acknowledged)
# Window data
mag_miss = window_data(process_input(sensor_miss))
mag_ack = window_data(process_input(sensor_ack))
# Window data
mag_miss = window_data(process_input(sensor_miss))
mag_ack = window_data(process_input(sensor_ack))
# Filter setup
kernel = 15
# apply filter
mag_miss_filter = sci.medfilt(mag_miss, kernel)
mag_ack_filter = sci.medfilt(mag_ack, kernel)
# calibrate data
mag_miss_cal = mf.calibrate_median(mag_miss)
mag_miss_cal_filter = mf.calibrate_median(mag_miss_filter)
mag_ack_cal = mf.calibrate_median(mag_ack)
mag_ack_cal_filter = mf.calibrate_median(mag_ack_filter)
# PLOT
sns.set_style("white")
current_palette = sns.color_palette('muted')
sns.set_palette(current_palette)
plt.figure(0)
# Plot RAW missed and acknowledged reminders
ax1 = plt.subplot2grid((2, 1), (0, 0))
plt.ylim([-1.5, 1.5])
plt.ylabel('Acceleration (g)')
plt.plot(mag_miss_cal, label='Recording 1')
plt.legend(loc='lower left')
ax2 = plt.subplot2grid((2, 1), (1, 0))
# Plot Missed Reminder RAW
plt.ylim([-1.5, 1.5])
plt.ylabel('Acceleration (g)')
plt.xlabel('t (ms)')
plt.plot(mag_ack_cal, linestyle='-', label='Recording 2')
plt.legend(loc='lower left')
# CALC AND SAVE STATS
stats_one = sp.calc_stats_for_data_stream_as_dictionary(mag_miss_cal)
stats_two = sp.calc_stats_for_data_stream_as_dictionary(mag_ack_cal)
data = [stats_one, stats_two]
write_to_csv(data, 'example_waves')
plt.show()
def test_reconstruction(X, gt, n_clusters, filename, from_file=False):
Ds = sdp_kmeans(X, n_clusters, method='cvx')
if from_file:
data = scipy.io.loadmat('{}{}.mat'.format(dir_name, filename))
rec_errors = data['rec_errors']
k_values = data['k_values']
else:
k_values = np.arange(200 + len(X)) + 1
rec_errors = []
for k in k_values:
print('{} / {}'.format(k, k_values[-1]))
rec_errors_k = []
for trials in range(50):
Y = symnmf_admm(Ds[-1], k=k)
rec_errors_k.append(check_completely_positivity(Ds[-1], Y))
rec_errors.append(rec_errors_k)
rec_errors = np.array(rec_errors)
scipy.io.savemat('{}{}.mat'.format(dir_name, filename),
dict(rec_errors=rec_errors,
k_values=k_values))
sns.set_style('white')
plt.figure(tight_layout=True)
gs = gridspec.GridSpec(1, 3)
ax = plt.subplot(gs[0])
plot_data_clustered(X, gt, ax=ax)
for i, D_input in enumerate(Ds):
ax = plt.subplot(gs[i + 1])
plot_matrix(D_input, ax=ax)
if i == 0:
ax.set_title('Original Gramian')
else:
ax.set_title('Layer {} (k={})'.format(i, n_clusters))
plt.savefig('{}{}_solution.pdf'.format(dir_name, filename))
plt.figure(tight_layout=True)
mean = np.mean(rec_errors, axis=1)
std = np.std(rec_errors, axis=1)
sns.set_palette('muted')
plt.fill_between(np.squeeze(k_values), mean - 2 * std, mean + 2 * std,
alpha=0.3)
plt.semilogy(np.squeeze(k_values), mean, linewidth=2)
plt.semilogy([n_clusters, n_clusters], [mean.min(), mean.max()],
linestyle='--', linewidth=2)
plt.xlabel('$r$', size='xx-large')
plt.ylabel('Relative reconstruction error', size='xx-large')
plt.ylim(np.floor(rec_errors.min() * 1e3) / 1e3, 1)
plt.savefig('{}{}_curve.pdf'.format(dir_name, filename))
def plot_2D_arrays(arrs, title='', xlabel='', xinterval=None, ylabel='', yinterval=None, line_names=[], simplified=False):
""" Plots multiple arrays in the same plot based on the specifications. """
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
plt.clf()
sns.set_style('darkgrid')
sns.set(font_scale=1.5)
sns.set_palette('husl', 8)
for i, arr in enumerate(arrs):
if arr.ndim != 2 or arr.shape[1] != 2:
raise ValueError(
'The array should be 2D and the second dimension should be 2!'
' Shape: %s' % str(arr.shape)
)
# Plot last one with black
if i == len(arrs) - 1:
plt.plot(arr[:, 0], arr[:, 1], color='black')
else:
plt.plot(arr[:, 0], arr[:, 1])
# If simplified, we don't show text anywhere
if not simplified:
plt.title(title[:30])
plt.xlabel(xlabel)
plt.ylabel(ylabel)
if line_names:
plt.legend(line_names, loc=6, bbox_to_anchor=(1, 0.5))
if xinterval:
plt.xlim(xinterval)
if yinterval:
plt.ylim(yinterval)
plt.tight_layout()
###############
# String handling
###############
