def plot_corr(model, X, absolute_value, threshold, figure_name='pcr'): activations, _ = get_activations(model, X) activations, _ = np.unique(activations, return_inverse=True, axis=0) min_activations = 10 # partition that are not on the domain are removed. for i, v in enumerate(np.all(activations == activations[0, :], axis=0)): if v: activations[:, i] = 0 # unique after corrections activations, _ = np.unique(activations, return_inverse=True, axis=0) nb_activations = activations.shape[0] nb_c_activations = min(nb_activations, min_activations) nb_params = -1 for n, p in model.named_parameters(): if len(p.shape) == 2: nb_params += 1 plt(figure_name, figsize=(nb_c_activations * 6.4, nb_params * 4.8)) vmin = 0. if absolute_value else -1. vmax = 1. print_info(str(nb_activations) + ' affine spaces used') for idx, a in enumerate(range(nb_c_activations)): tc = 0 c = 0 for name, params in model.named_parameters(): if len(params.shape) == 2: A = params.detach().numpy() B = np.zeros((A.shape[0], A.shape[0])) plt(figure_name).subplot(nb_params, nb_c_activations, 1 + c * nb_c_activations + idx) for i in range(A.shape[0]): for j in range(A.shape[0]): if activations[idx, tc + i] != 0 and activations[idx, tc + j] != 0: B[i, j] = np.dot(A[i, :], A[j, :]) / np.linalg.norm( A[i, :]) / np.linalg.norm(A[j, :]) else: B[i, j] = None if absolute_value: B = np.abs(B) if type(threshold) is not bool: B = (B > threshold).astype(int) plt(figure_name).imshow(B, vmin=vmin, vmax=vmax) plt(figure_name).title(name) plt(figure_name).colorbar() tc += A.shape[0] c += 1 if tc >= activations.shape[1]: break
def plot_gradient_field(X, y, model, ax=None, figure_name='pfg', normalized=True): from torch.autograd import Variable if ax is None: ax = plt(figure_name).gca() # disabling grad grads = [] model.eval() for param in model.parameters(): grads.append(param.requires_grad) param.requires_grad = False num = 20 x_min, x_max = ax.get_xlim() y_min, y_max = ax.get_ylim() xx, yy = np.meshgrid(np.linspace(x_min, x_max, num), np.linspace(y_min, y_max, num)) _X = np.c_[xx.ravel(), yy.ravel()].astype(np.float32) data = torch.from_numpy(_X).float() d = Variable(data, requires_grad=True) output = model(d) for i in range(d.shape[0]): output[i][0].backward(retain_graph=True) # plotting U = d.grad[:, 0] V = d.grad[:, 1] U = U.reshape(xx.shape) V = V.reshape(yy.shape) E_norm = 2 * np.sqrt(U**2 + V**2) if normalized: U = U / E_norm V = V / E_norm ax.quiver(xx, yy, U, V, E_norm, cmap=plt().cm.coolwarm, units='xy', scale=5.) else: ax.quiver(xx, yy, U, V, color='darkred', units='xy', scale=5.) # reestablishing grad for grad, param in zip(grads, model.parameters()): param.requires_grad = grad return ax
def plot_partition(X, y, model, figure_name='pp', ax=None): if ax is None: ax = plt(figure_name).gca() plot_dataset(X, y, ax=ax, alpha=.25) num = 500 x_min, x_max = ax.get_xlim() y_min, y_max = ax.get_ylim() xx, yy = np.meshgrid(np.linspace(x_min, x_max, num), np.linspace(y_min, y_max, num)) _X = np.c_[xx.ravel(), yy.ravel()].astype(np.float32) _, Z = get_activations(model, _X) Z = Z.reshape(xx.shape) levels = len(np.unique(Z)) im = Image.fromarray(((Z / levels) * 255.).astype(np.uint8), mode='L') im = im.filter(ImageFilter.FIND_EDGES) im = im.point(lambda p: p > 0 and 255) ax.imshow(im, origin='lower', extent=(x_min, x_max, y_min, y_max), cmap='gray', aspect='auto') ax.imshow(Z / levels, origin='lower', extent=(x_min, x_max, y_min, y_max), alpha=.75, cmap='gray', aspect='auto') return ax
def print_mask(self, save=False, show=True, color=None, figure_name='map_mask', ax=None): """ Plot mask (original 1st read layer) """ if ax is None: ax = plt(figure_name, figsize=special_parameters.plt_default_size).gca() reverse_mask = (self.mask == 0).astype(np.int) if color is not None: reverse_mask[color[0], color[1]] = -15 reverse_mask = np.ma.masked_where(reverse_mask == 1, reverse_mask) # Plot ax.imshow(reverse_mask, cmap=matplotlib.pyplot.get_cmap('gray'), vmin=-15, vmax=5) ax.set_xlabel('Longitude') ax.set_ylabel('Latitude') ax.set_title('Land-sea mask')
def plot_activation_rate(X, y, model, ax=None, layer=None, figure_name='par', colorbar=True): if ax is None: ax = plt(figure_name).gca() # plot_dataset(X, y, ax=ax, alpha=.25) num = 500 x_min, x_max = ax.get_xlim() y_min, y_max = ax.get_ylim() xx, yy = np.meshgrid(np.linspace(x_min, x_max, num), np.linspace(y_min, y_max, num)) _X = np.c_[xx.ravel(), yy.ravel()].astype(np.float32) Z, _ = get_activations(model, _X, layer=layer) Z = np.average(Z, axis=1) Z = Z.reshape(xx.shape) c = ax.contourf(xx, yy, Z, cmap='gray', vmin=Z.min(), vmax=Z.max(), alpha=.5) if colorbar: ax.figure.colorbar(c, ax=ax, alpha=.75) return ax
def plot_decision_boundary(model, figure_name='pdb', ax=None): """ Plot the decision boundary :param model: the model :param figure_name: figure name, by default pdb :param ax: an axis if needs to be plotted on an other figure :return: the axis of the current figure """ pred_func = make_pred_func(model) if ax is None: ax = plt(figure_name).gca() if not callable(pred_func) and hasattr(pred_func, 'predict'): pred_func = pred_func.predict num = 1000 x_min, x_max = ax.get_xlim() y_min, y_max = ax.get_ylim() xx, yy = np.meshgrid(np.linspace(x_min, x_max, num), np.linspace(y_min, y_max, num)) zz = pred_func(np.c_[xx.ravel(), yy.ravel()]).cpu() zz = zz.reshape(xx.shape) ax.contourf(xx, yy, zz, alpha=.4, zorder=-1) return ax
def show_view(self, figure_name='regatta_view', show=False): view = self.get_view() uwind = view[0, :, :] vwind = view[1, :, :] mask = view[2, :, :] print(view.shape) fig = plt(figure_name) # ax = fig.gca() fig.subplot(1, 3, 1) fig.imshow(np.squeeze(uwind)) fig.title('u wind (m.s-1)') fig.subplot(1, 3, 2) fig.imshow(np.squeeze(vwind)) fig.title('v wind (m.s-1)') fig.subplot(1, 3, 3) fig.imshow(np.squeeze(mask)) fig.title('mask') save_fig(figure_name=figure_name)
def __call__(self, validation_id): ax = plt('VCallback').subplot(self.nb_calls + 2, 1, validation_id + 1) plot_dataset(self.dataset.dataset, self.dataset.labels, ax=ax, figure_name='VCallback') plot_decision_boundary(self.model, ax=ax, figure_name='VCallback') plot_activation_rate(self.dataset.dataset, self.dataset.labels, self.model, ax=ax, figure_name='VCallback') plot_gradient_field(self.dataset.dataset, self.dataset.labels, self.model, ax=ax, normalized=True, figure_name='VCallback')
def print_wind(self, idx, save=False, show=True, figure_name='map_wind', ax=None): """ Plot the u_v_wind components as quiver (basemap) from the 1st u, v components read """ if ax is None: ax = plt(figure_name, figsize=special_parameters.plt_default_size).gca() self.print_mask(show=False, save=False, ax=ax) x_grid = np.arange(0, self.mask.shape[1]) y_grid = np.arange(0, self.mask.shape[0]) x_mesh, y_mesh = np.meshgrid(x_grid, y_grid) intensity = np.sqrt( np.power(np.flip(self.gribs[idx, 0, :, :], axis=0), 2) + np.power(np.flip(self.gribs[idx, 1, :, :], axis=0), 2)) u10 = np.flip(self.gribs[idx, 0, :, :], axis=0).flatten() v10 = np.flip(self.gribs[idx, 1, :, :], axis=0).flatten() wind_speed = np.sqrt((u10**2 + v10**2)) # Create colour bar norm = matplotlib.colors.Normalize() norm.autoscale(wind_speed) cm = matplotlib.cm.CMRmap # selecting the colourmap sm = matplotlib.cm.ScalarMappable(cmap=cm, norm=norm) sm.set_array([]) ax.pcolormesh(x_mesh, y_mesh, intensity, alpha=0.5, cmap=cm) # Plot Y, X = np.mgrid[0:self.gribs[idx, 0].shape[0]:self.granularity, 0:self.gribs[idx, 0].shape[1]:self.granularity] q = ax.barbs( X, Y, np.flip(self.gribs[idx, 0, ::self.granularity, ::self.granularity], axis=0), np.flip(self.gribs[idx, 1, ::self.granularity, ::self.granularity], axis=0), length=3, linewidths=0.5) ax.set_xlabel('Longitude') ax.set_ylabel('Latitude') cbar = ax.figure.colorbar(sm) cbar.set_label('velocity (m.s-1)') ax.set_title('Wind velocity ' + str(self.time_refs[idx, 3]))
def plot_representation(fig_name='representation_tsne', file_name=None): file_name = fig_name if file_name is None else file_name ax = plt(fig_name, figsize=(8, 10)).gca() path = os.path.join(last_experiment_path(experiment_name), file_name + '.dump') with open(path, 'rb') as f: artists = pickle.load(f) colors = cm.tab20b(np.linspace(0, 1, len(artists))) for row in artists: ax.scatter(row[0][:, 0], row[0][:, 1], c=colors[row[1]], label=clean_labels(row[2])) ax.legend(bbox_to_anchor=(0, 0, 1, 1), bbox_transform=plt(fig_name).gcf().transFigure, prop={'size': 6}, ncol=4, loc=3) ax.set_title('Painting representation')
def plot_layer_output_corr_interspace(model, X, absolute_value, threshold, min_activations=10000, figure_name='ploci'): #Compute neural directions first vectors, vmin, vmax = compute_neural_directions(model, X, absolute_value, threshold, min_activations) plt(figure_name, figsize=(6.4, len(vectors) * 4.8)) # compute interspace co-linearity for li, l in enumerate(vectors): cos = np.zeros((len(l), len(l))) for r in range(len(l)): for c in range(len(l)): if np.count_nonzero(l[r]) > 0 and np.count_nonzero(l[c]) > 0: cos[r, c] = np.dot(l[r], l[c]) / np.linalg.norm( l[r]) / np.linalg.norm(l[c]) else: cos[r, c] = None if absolute_value: cos = np.abs(cos) if type(threshold) is not bool: cos = (cos > threshold).astype(int) plt(figure_name).subplot(len(vectors), 1, 1 + li) plt(figure_name).imshow(cos, vmin=vmin, vmax=vmax) plt(figure_name).colorbar() print('colorbar') plt(figure_name).title('Layer: ' + str(li + 1)) # plt(figure_name).tight_layout() return vectors
def plot_partition_distribution(model, X, figure_name='plot_pat_dist', ax=None): if ax is None: fig = plt(figure_name).figure() ax = fig.gca() _, activations = get_activations(model, X) unique, counts = np.unique(activations, return_counts=True, axis=0) print(len(unique)) sorted_counts = np.sort(counts)[::-1] cumulative_sum = sorted_counts.cumsum() / sorted_counts.sum() ax.plot(cumulative_sum) ax.grid()
def plot(self, plot_weather=False, save=False, show=True, track=None, figure_name='regatta_plot'): if track is not None: self.track = track ax = plt(figure_name, figsize=special_parameters.plt_default_size).gca() # draw land if plot_weather: # current simulation timestamp t_idx = self.numpy_grib.physical_time_to_idx(self.start_timestamp + self.timedelta) self.numpy_grib.print_wind(show=False, save=False, idx=t_idx, ax=ax) else: self.numpy_grib.print_mask(show=False, save=False, figure_name=figure_name, ax=ax) # current position y_position, x_position = project(latitude=self.position[1], longitude=self.position[0], grib=self.numpy_grib) y_position = self.numpy_grib.latitudes.shape[0] - y_position ax.plot(x_position, y_position, 's', markersize=4, color="blue") # target y_target, x_target = project(latitude=self.target[1], longitude=self.target[0], grib=self.numpy_grib) y_target = self.numpy_grib.latitudes.shape[0] - y_target ax.plot(x_target, y_target, 'bo', markersize=6, color="green") # track X, Y = [], [] for lat, lon in zip(self.track[:, 1], self.track[:, 0]): y, x = project(lat, lon, self.numpy_grib) X.append(x) Y.append(self.numpy_grib.latitudes.shape[0] - y) ax.plot(X, Y, '-', color="red") ax.set_xlabel('Longitude') ax.set_ylabel('Latitude') ax.set_title('Offshore Regatta (at ' + str(self.start_timestamp + self.timedelta) + ')', y=1, fontsize=12) save_fig(figure_name=figure_name)
def plot_dataset(dataset, y, ax=None, figure_name='plot_dataset', **kwargs): """ Plot the dataset :param dataset: the dataset, must be 2D :param y: the label :param ax: the axis if needs to be plotted on an other figure :param figure_name: plot_dataset by default :param kwargs: :return: """ locals().update(kwargs) if ax is None: ax = plt(figure_name).gca() n_classes = len(np.unique(y)) colors = ['red', 'cyan', 'orange'] for k in range(n_classes): dataset_k = dataset[y == k] ax.scatter(dataset_k[:, 0], dataset_k[:, 1], color=colors[k], alpha=0.5) return ax
from datascience.visu.util import plt, save_fig noise = [i/10 for i in range(1, 11)] OU = lambda x: x - eta * x - n * normal(0, 1, 1)[0] SGD = lambda x: x - eta * (x - n * x * np.abs(normal(0, 1, 1)[0])) print(normal(0, 1, 1)) nb_iterations = 300 all_positions = [] for n in noise: pos = 150 positions = [pos] eta = 0.05 all_positions.append(positions) for _ in range(nb_iterations): pos = SGD(pos) positions.append(pos) ax = plt('OU').gca() for i, j in zip(noise, all_positions): print(i,j) ax.plot(j, label='noise: '+str(i)) ax.legend() save_fig()
def initial_call(self, modulo, nb_calls, dataset, model): super().initial_call(modulo, nb_calls, dataset, model) self.fig = plt('VCallback', figsize=(6.4, (nb_calls + 2) * 4.8)) self.__call__(0)
def plot_separator(separator, figure_name='separator', ax=None, **kwargs): if ax is None: ax = plt(figure_name).gca() ax.plot(separator[0], separator[1], **kwargs)
def pplot_patch(patch, resolution=1., return_fig=True, header=None): """ plot a patch that has already been extracted :param header: :param patch: :param resolution: :param return_fig: :return: """ if header is None: header = ['' for _ in range(len(patch))] # computing number of rows and columns... nb_rows = (len(patch) + 4) // 5 nb_cols = 5 plt('patch_ext', figsize=(nb_cols * 6.4 * resolution, nb_rows * 4.8 * resolution)) fig = get_figure('patch_ext') for i, (t, p) in enumerate(zip(header, patch)): plt('patch_ext').subplot(nb_rows, nb_cols, i + 1) plt('patch_ext').title(t, fontsize=20) plt('patch_ext').imshow(p, aspect='auto') if len(p.shape) < 3: plt('patch_ext').colorbar() fig.tight_layout() if return_fig: return fig else: fig.show() plt('patch_ext').close(fig)
def plot_on_map(activations, map_ids, n_cols=1, n_rows=1, figsize=4, log_scale=False, mean_size=1, selected=tuple(), legend=None, output="activations", style="grey", exp_scale=False, cmap=None, alpha=None, bad_alpha=1., font_size=12, color_text='black', color_tick='black'): if log_scale: print_info("apply log...") activations = activations + 1.0 activations = np.log(activations) elif exp_scale: print_info("apply exp...") p = np.full(activations.shape, 1.2) activations = np.power(p, activations) print_info("construct array activation map...") pos = [] max_x = 0 max_y = 0 for id_ in map_ids: x, y = id_.split("_") x, y = int(x), int(y) pos.append((x, y)) if x > max_x: max_x = x if y > max_y: max_y = y size = max(max_x + 1, max_y + 1) while size % mean_size != 0: size += 1 nb = n_cols * n_rows act_map = np.ndarray((nb, size, size)) act_map[:] = np.nan print_info("select neurons to print...") if len(selected) > 0: list_select = selected else: list_select = random.sample(list(range(activations.shape[1])), nb) print_info("fill activation map array...") for k, act in enumerate(activations): for idx, j in enumerate(list_select): x, y = pos[k][0], pos[k][1] act_map[idx, x, y] = act[j] """ fig, axs = plt.subplots(n_rows, n_cols, sharex='col', sharey='row', figsize=(n_cols*figsize*1.2, n_rows*figsize)) fig.subplots_adjust(wspace=0.5) plt.tight_layout(pad=1.5) print_info("make figure...") for j in range(nb): if mean_size != 1: height, width = act_map[j].shape act_map_j = np.ma.average(np.split(np.ma.average(np.split(act_map[j], width // mean_size, axis=1), axis=2), height // mean_size, axis=1), axis=2) else: act_map_j = act_map[j] masked_array = np.ma.array(act_map_j, mask=np.isnan(act_map_j)) cmap = matplotlib.cm.inferno cmap.set_bad('grey', 1.) im = axs[j // n_cols, j % n_cols].imshow(masked_array, cmap=cmap, interpolation='none') axs[j // n_cols, j % n_cols].set_title(str(list_select[j])) divider = make_axes_locatable(axs[j // n_cols, j % n_cols]) cax = divider.append_axes("right", size="5%", pad=0.05) fig.colorbar(im, cax=cax) """ font = {'family': 'normal', 'weight': 'bold', 'size': font_size} matplotlib.rc('font', **font) if legend is None: legend = list(map(str, list_select)) mplt.rcParams['text.color'] = color_text mplt.rcParams['axes.labelcolor'] = color_tick mplt.rcParams['xtick.color'] = color_tick mplt.rcParams['ytick.color'] = color_tick plt(output, figsize=(n_cols * figsize * 1.2, n_rows * figsize)) fig = get_figure(output) fig.subplots_adjust(wspace=0.05) print_info("make figure...") for j in range(nb): if mean_size != 1: height, width = act_map[j].shape act_map_j = np.nanmean(np.split(np.nanmean(np.split(act_map[j], width // mean_size, axis=1), axis=2), height // mean_size, axis=1), axis=2) else: act_map_j = act_map[j] print(act_map_j[2, 572]) masked_array = np.ma.array(act_map_j, mask=np.isnan(act_map_j)) if cmap is None: if style == "grey": cmap = matplotlib.cm.inferno cmap.set_bad('grey', bad_alpha) elif style == "white": cmap = matplotlib.cm.inferno cmap.set_bad('white', bad_alpha) ax = plt(output).subplot(n_rows, n_cols, j + 1) ax.set_facecolor((0, 0, 0, 0)) im = plt(output).imshow(masked_array, cmap=cmap, interpolation='none', alpha=alpha) plt(output).title(legend[j]) divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="5%", pad=0.05) plt(output).colorbar(im, cax=cax) fig.tight_layout(pad=0.05) fig.patch.set_alpha(0.0) save_fig(figure_name=output, extension='png')
def plot_layer_output_corr(model, X, absolute_value, threshold, figure_name='ploc'): # this method only works on fully connected models if type(model) is not fully_connected.Net: print_errors(str(type(model)) + ' must be of type ' + str(fully_connected.Net) + '.', do_exit=True) layers = [m for m in model.modules() if type(m) in (BatchNorm1d, Linear)][:-1] final_layers = [] it = 0 while it < len(layers): # linear layer M = layers[it] it += 1 linear_app = M.weight.detach().numpy() if it < len(layers) and type(layers[it]) is BatchNorm1d: A = layers[it] var = np.diag(A.running_var.numpy()) gamma = np.diag(A.weight.detach().numpy()) bn = np.matmul(gamma, np.linalg.inv(var)) linear_app = np.matmul(bn, linear_app) it += 1 final_layers.append(linear_app) # get activations activations, _ = get_activations(model, X) activations, _ = np.unique(activations, return_inverse=True, axis=0) # partition that are not on the domain are removed. for i, v in enumerate(np.all(activations == activations[0, :], axis=0)): if v: activations[:, i] = 0 # unique after corrections activations, _ = np.unique(activations, return_inverse=True, axis=0) min_activations = 10 nb_c_activations = min(activations.shape[0], min_activations) plt(figure_name, figsize=(nb_c_activations * 6.4, len(final_layers) * 4.8)) vmin = 0. if absolute_value else -1. vmax = 1. for i in range(min_activations): la = None for li, l in enumerate(final_layers): cos = np.zeros((l.shape[0], l.shape[0])) activated = activations[i][li * l.shape[0]:(li + 1) * l.shape[0]] if la is None: la = final_layers[li] * activated[:, np.newaxis] else: la = np.matmul(final_layers[li], la) * activated[:, np.newaxis] for r in range(l.shape[0]): for c in range(l.shape[0]): if activations[i, li * l.shape[0] + r] != 0 and activations[i, li * l.shape[0] + c] != 0: cos[r, c] = np.dot(la[r, :], la[c, :]) / np.linalg.norm( la[r, :]) / np.linalg.norm(la[c, :]) else: cos[r, c] = None if absolute_value: cos = np.abs(cos) if type(threshold) is not bool: cos = (cos > threshold).astype(int) plt(figure_name).subplot(len(final_layers), nb_c_activations, 1 + li * nb_c_activations + i) plt(figure_name).imshow(cos, vmin=vmin, vmax=vmax) plt(figure_name).title('Layer: ' + str(li + 1)) plt(figure_name).colorbar()
import numpy as np import os from engine.parameters.special_parameters import get_parameters from engine.path import last_experiment_path experiment_name = get_parameters('roc_experiment', 'country') path = os.path.join(last_experiment_path(experiment_name), 'results.csv') df = pd.read_csv(path, header='infer', sep=';') print(df) fpr, tpr, thresholds = roc_curve(df.true_label, df.prediction, pos_label=1) ax = plt('roc_curve').gca() ax.set_xlim([-0.007, 1.0]) ax.set_ylim([0.0, 1.01]) ax.set_xlabel('False Positive Rate') ax.set_ylabel('True Positive Rate') ax.set_title('Receiver operating characteristic (AUC: %.3f)' % auc(fpr, tpr)) ax.plot([0, 1], [0, 1], color='red', linestyle='--', label='Random model') ax.plot(fpr, tpr, color='yellow', label='IArt') ax.plot([0, 0, 1], [0, 1, 1], color='green', linestyle='--', label='Perfect model') ax.legend(loc="lower right")
from datascience.visu.util import plt, save_fig from numpy import linspace, power ax = plt('x_square').gca() x = linspace(-2, 2, 100) x_small = linspace(0, 2, 100) ax.set_title('$x^2$') ax.plot(x, power(x, 2), label='$x^2+0x^3$') ax.plot(x, power(2 * x, 2), label='$4x^2+0x^3$') ax.plot(x, power(2 * x, 2) + power(x, 3) * 2, label='$4x^2+2x^3$') ax.plot(x, power(2 * x, 2) + power(x, 3) * 3, label='$4x^2+3x^3$') ax.plot(x_small, 8 * x_small - 4, label='tangent: $8x-4$') ax.legend() save_fig()
from datascience.visu.util import plt, save_fig import numpy as np ax = plt('sde_omega').gca() x = np.linspace(0, 3500, 5000) def f(t, omega=32, eta=0.1, b=10.): kappa = 0.015 kappa_k = kappa var_x_delta = 1. lambda_jk = 1. w_0 = 1. result = eta / (b * 2) * (var_x_delta / lambda_jk) w_t = np.log(kappa * omega * kappa_k * t + np.exp(kappa * omega * w_0)) w_t /= (kappa * omega + (kappa**2) * kappa_k * (omega**2) * t + np.exp(kappa * omega * w_0)) result *= w_t**2 result *= (1 - np.exp(-2 * lambda_jk * eta * t)) return result for width in [16 * i for i in range(2, 5)]: ax.plot(x, f(x, width), label='$\\omega$=%ld' % width) ax.legend() save_fig('sde_omega') ax = plt('sde_eta_b').gca()