I want to plot the learning curve (loss & accuracy plot) for my gan? I try different solution but still can't plot the learning curve for my gan. I tried to use fit and history function but I get error and can't plot loss & accuracy curve. If anyone can help?
I run my code in google colab. Since I only train the discriminator I tried to use fit & history function in the definition of discriminator & gan but still get error
from tensorflow.keras.layers import Dense, Conv2DTranspose, LeakyReLU, Reshape, BatchNormalization, Activation, Conv2D
from tensorflow.keras.models import Model, Sequential
import matplotlib.pyplot as plt
import numpy as np
from tensorflow.keras.layers import Conv2D, Flatten, Dropout
from tensorflow.keras import optimizers
import tensorflow as tf
def image_generator():
generator = Sequential()
generator.add(Dense(256*4*4, input_shape = (100,)))
#generator.add(BatchNormalization())
generator.add(LeakyReLU())
generator.add(Reshape((4,4,256)))
generator.add(Conv2DTranspose(128,kernel_size=3, strides=2, padding = "same"))
#generator.add(BatchNormalization())
generator.add(LeakyReLU(alpha=0.2))
generator.add(Conv2DTranspose(128,kernel_size=3, strides=2, padding = "same"))
#generator.add(BatchNormalization())
generator.add(LeakyReLU(alpha=0.2))
generator.add(Conv2DTranspose(128,kernel_size=3, strides=2, padding = "same"))
#generator.add(BatchNormalization())
generator.add(LeakyReLU(alpha=0.2))
generator.add(Conv2D(3,kernel_size=3, padding = "same", activation='tanh'))
return(generator)
model_generator = image_generator()
model_generator.summary()
# Define input data
def generate_data_entry(n_samples):
X = np.random.randn(100 * n_samples)
X = X.reshape(n_samples, 100)
return X
def create_data_fake(model_generator, n_samples):
input = generate_data_entry(n_samples)
X = model_generator.predict(input)
y = np.zeros((n_samples, 1))
return X,y
number_samples = 4
X,_ = create_data_fake(model_generator, number_samples)
# Visualize results
for i in range(number_samples):
plt.subplot(2, 2, 1 + i)
plt.axis('off')
plt.imshow(X[i])
def images_discriminator():
discriminator = Sequential()
discriminator.add(Conv2D(64, kernel_size=3, padding = "same", input_shape = (32,32,3)))
discriminator.add(LeakyReLU(alpha=0.2))
#discriminator.add(Dropout(0.2))
discriminator.add(Conv2D(128, kernel_size=3,strides=(2,2), padding = "same"))
discriminator.add(LeakyReLU(alpha=0.2))
#discriminator.add(Dropout(0.2))
discriminator.add(Conv2D(128, kernel_size=3,strides=(2,2), padding = "same"))
discriminator.add(LeakyReLU(alpha=0.2))
#discriminator.add(Dropout(0.2))
discriminator.add(Conv2D(256, kernel_size=3, strides=(2,2), padding = "same"))
discriminator.add(LeakyReLU(alpha=0.2))
#discriminator.add(Dropout(0.2))
discriminator.add(Flatten())
discriminator.add(Dropout(0.4))
discriminator.add(Dense(1, activation='sigmoid'))
opt = tf.keras.optimizers.Adam(learning_rate=0.0002 ,beta_1=0.5)
discriminator.compile(loss='binary_crossentropy', optimizer= opt , metrics = ['accuracy'])
return(discriminator)
model_discriminator = images_discriminator()
model_discriminator.summary()
from tensorflow.keras.datasets import cifar10
import random
import tensorflow as tf
import numpy as np
from tensorflow.keras import backend
import pandas as pd
import matplotlib.pyplot as plt
import keras
%matplotlib inline
(Xtrain, Ytrain), (testx, testy) = cifar10.load_data()
def load_images():
(Xtrain, Ytrain), (testx, testy) = cifar10.load_data()
# we stayed with the dogs
indice = np.where(Ytrain == 0)
indice = indice[0]
Xtrain = Xtrain[indice, :,:,:]
# Normalize the data
X = Xtrain.astype('float32')
X = (X - 127.5) / 127.5
return X
print(load_images().shape)
def load_data_reales(dataset, n_samples):
ix = np.random.randint(0, dataset.shape[0], n_samples)
X = dataset[ix]
y = np.ones((n_samples, 1))
return X,y
def load_data_fake(n_samples):
X = np.random.rand(32 * 32 * 3 * n_samples)
X = -1 + X * 2
X = X.reshape((n_samples, 32,32,3))
y = np.zeros((n_samples, 1))
return X,y
def train_discriminator(model, dataset, n_iterations=20, batch = 128):
medium_batch = int(batch/2)
for i in range(n_iterations):
X_real, y_real = load_data_reales(dataset, medium_batch)
los_real, acc_real = model.train_on_batch(X_real, y_real)
X_fake, y_fake = load_data_fake(medium_batch)
los_fake, acc_fake = model.train_on_batch(X_fake, y_fake)
print(str(i+1) + ' Real:' + str(acc_real*100) + ', Fake:' + str(acc_fake*100))
dataset = load_images()
train_discriminator(model_discriminator, dataset)
def my_loss_function(x_real,x_fake):
la=tf.keras.losses.BinaryCrossentropy()
my_loss_function = la(x_real, x_fake)
return my_loss_function
def create_gan(discriminator, generator):
discriminator.trainable=False
gan = Sequential()
gan.add(generator)
gan.add(discriminator)
opt = tf.keras.optimizers.Adam(learning_rate=0.0002,beta_1=0.5)
return gan
gan = create_gan(model_discriminator,model_generator)
gan.summary()
def show_images_generated(data_fake, epoch):
now = datetime.now()
now = now.strftime("%Y%m%d_%H%M%S")
# we make the data go from 0 to 1
data_fake = (data_fake + 1) / 2.0
for i in range(10):
plt.imshow(data_fake[i])
plt.axis('off')
name = str(epoch) + '_generated_image_' + str(i) + '.png'
plt.savefig(name, bbox_inches='tight')
plt.close()
def evaluate_and_save(model_generator, epoch, medium_dataset):
# We save the model
now = datetime.now()
now = now.strftime("%Y%m%d_%H%M%S")
name = str(epoch) + '_' + str(now)+"_model_generator_" + '.h5'
model_generator.save(name)
# We generate new data
X_real,Y_real = load_data_reales(dataset, medium_dataset)
X_fake, Y_fake = create_data_fake(model_generator,medium_dataset)
# We evaluate the model
_, acc_real = model_discriminator.evaluate(X_real, Y_real)
_, acc_fake = model_discriminator.evaluate(X_fake, Y_fake)
print('Acc Real:' + str(acc_real*100) + '% Acc Fake:' + str(acc_fake*100)+'%')
def training(data, model_generator, model_discriminator, epochs, n_batch, beginning = 0):
dimension_batch = int(data.shape[0]/n_batch)
medium_dataset = int(n_batch/2)
# We iterate over the epochs
for epoch in range(beginning, beginning + epochs):
# We iterate over all batches
for batch in range(n_batch):
# We load all the real data
X_real,Y_real = load_data_reales(dataset, medium_dataset)
# We train the discriminator withEnrenamos discriminator with data reales
cost_discriminator_real, _ = model_discriminator.train_on_batch(X_real, Y_real)
X_fake, Y_fake = create_data_fake(model_generator,medium_dataset)
cost_discriminator_fake, _ = model_discriminator.train_on_batch(X_fake, Y_fake)
# We generate input images for the GAN
X_gan = generate_data_entry(medium_dataset)
Y_gan = np.ones((medium_dataset, 1))
# We train the GAN with fake data
cost_gan = gan.train_on_batch(X_gan, Y_gan)
# Every 10 epochs we show the results and cost
if (epoch+1) % 10 == 0:
evaluate_and_save(model_generator,epoch = epoch, medium_dataset= medium_dataset)
show_images_generated(X_fake, epoch = epoch)
training(dataset, model_generator, model_discriminator, epochs = 10, n_batch=128, beginning = 0)
X_fake, _ = create_data_fake(n_samples=49, model_generator=model_generator)
X_fake = (X_fake+1)/2
for i in range(49):
plt.subplot(7,7,i+1)
plt.axis('off')
plt.imshow(X_fake[i])
# We generate new data
X_real1,Y_real1 = load_data_reales(dataset, int(15))
X_fake1, Y_fake1 = create_data_fake(model_generator,int(15))
# We evaluate the model
_, acc_real = model_discriminator.evaluate(X_real1, Y_real1)
_, acc_fake = model_discriminator.evaluate(X_fake1, Y_fake1)
print('Acc Real:' + str(acc_real*100) + '% Acc Fake:' + str(acc_fake*100)+'%')
Related
I am doing a nested plot but my labels are repeating as many times as a loop, although it is out of the loop. In fact, I need three labels which correspond to 6.96K, 0.268K, 0.02025K
import matplotlib.pyplot as plt
import numpy as np
Freq = np.arange(1, 10, 0.1)
T = 6.96
for f in Freq:
def quanta(f,T):
return (f*T)
final = quanta(f,T)
plt.plot(f, final, 'o', color='red', linewidth=1.5, markersize=4, label = '6.96K')
plt.legend(shadow=True, loc=(0.5, 0.2) )
T = 0.268
for f in Freq:
def quanta(f,T):
return (f*T)
final = quanta(f,T)
plt.plot(f, final, 'o', color='orange', linewidth=1.5, markersize=4,label = '0.268K')
plt.legend(shadow=True, loc=(0.5, 0.2) )
T = 0.02025
for f in Freq:
def quanta(f,T):
return (f*T)
final = quanta(f,T)
plt.plot(f, final, 'o', color='Blue', linewidth=1.5, markersize=4,label = '0.02025K')
plt.legend(shadow=True, loc=(0.5, 0.2) )
plt.show()
I'm currently trying to find a way how to get a single label prediction from my GNN.I'd like to create a list of ground truths compared to how the model predicts the label.
My code is as following, ran in google collab:
Should I create a validation step or is there another way about this? I'm very new to this.
# Load the dataset
dataset = TUDataset(
root=".", name="Mutagenicity",
transform=AddSymbols(),
).shuffle()
from torch_geometric.data import DataLoader
loader = DataLoader(dataset, batch_size=32, shuffle=True)
data_batch = next(iter(loader))
print(data_batch)
print("Number of graphs in the batch:",data_batch.num_graphs)
import torch
from torch_scatter import scatter
from torch_geometric.utils import to_dense_adj
class GraphConvolution(torch.nn.Module):
def __init__(self, num_input_features, num_output_features):
super().__init__()
self.W1 = torch.nn.Parameter(torch.randn(num_input_features, num_output_features)*0.1)
self.W2 = torch.nn.Parameter(torch.randn(num_input_features, num_output_features)*0.1)
def forward(self, x, edge_index):
adj = to_dense_adj(edge_index)
neighbors_aggregation = adj # x
out = x # self.W1 + neighbors_aggregation # self.W2
return out
from torch.nn import Linear, LogSoftmax
import torch.nn.functional as F
from torch_geometric.nn import GraphConv, global_add_pool
class GNN(torch.nn.Module):
def __init__(
self,
num_classes,
hidden_dim,
node_features_dim,
edge_features_dim=None
):
super(GNN, self).__init__()
self.hidden_dim = hidden_dim
self.conv1 = GraphConv(node_features_dim, hidden_dim)
self.conv2 = GraphConv(hidden_dim, hidden_dim)
self.conv3 = GraphConv(hidden_dim, hidden_dim)
self.conv4 = GraphConv(hidden_dim, hidden_dim)
self.conv5 = GraphConv(hidden_dim, hidden_dim)
self.fc1 = Linear(hidden_dim, hidden_dim)
self.fc2 = Linear(hidden_dim, num_classes)
self.readout = LogSoftmax(dim=-1)
def forward(self, x, edge_index, batch):
x = F.relu(self.conv1(x, edge_index))
x = F.relu(self.conv2(x, edge_index))
x = F.relu(self.conv3(x, edge_index))
x = F.relu(self.conv4(x, edge_index))
x = F.relu(self.conv5(x, edge_index))
x = global_add_pool(x, batch)
x = F.relu(self.fc1(x))
x = F.dropout(x, p=0.5, training=self.training)
x = self.fc2(x)
return self.readout(x)
from torch_geometric.loader import DataLoader
from tqdm.auto import tqdm
# If possible, we use a GPU
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using device:", device)
idx_train_end = int(len(dataset) * .5)
idx_valid_end = int(len(dataset) * .7)
BATCH_SIZE = 128
BATCH_SIZE_TEST = len(dataset) - idx_valid_end
# In the test loader we set the natch size to be equal to the size of the whole test set
loader_train = DataLoader(dataset[:idx_train_end], batch_size=BATCH_SIZE, shuffle=True)
loader_valid = DataLoader(dataset[idx_train_end:idx_valid_end], batch_size=BATCH_SIZE, shuffle=True)
loader_test = DataLoader(dataset[idx_valid_end:], batch_size=BATCH_SIZE_TEST, shuffle=False)
from src import compute_accuracy
def train_model(loader_train, loader_valid, model, optimizer, loss_function, N_EPOCHS):
# Prepare empy lists for logging
train_losses = []
train_accs = []
val_accs = []
for epoch in tqdm(range(N_EPOCHS)):
epoch_loss = 0
for batch in tqdm(loader_train, leave=False):
batch.to(device)
out = model(batch.x, batch.edge_index, batch.batch)
loss = loss_function(out, batch.y.flatten())
optimizer.zero_grad()
loss.backward()
optimizer.step()
acc_train = compute_accuracy(model, loader_train)
acc_valid = compute_accuracy(model, loader_valid)
with torch.no_grad():
train_accs.append(acc_train)
val_accs.append(acc_valid)
train_losses.append(loss)
print(f"Epoch: {epoch}, Loss: {loss}")
I have created a fit via the Gamma_3P distribution with alpha, beta and gamma.
The Problem is, that the output y values(red) does not match the distribution(blue).
Thank you in advance for Help.
Code Following:
#test numpy plot
from reliability.Distributions import Gamma_Distribution
from reliability.Fitters import Fit_Gamma_3P
import matplotlib.pyplot as plt
x_min = 0
x_max = 10000
alpha_G = 1827.9715783463666
beta_G = 0.5175119001035541
gamma_G = 0.9999
Gamma_fit_created = Gamma_Distribution(alpha=alpha_G,beta=beta_G, gamma=gamma_G)
y_values = Gamma_fit_created.SF(xmin = x_min, xmax = x_max, label='fit function',color='green', show_plot = False)
#since the output array is 200 values within the limits, I adapted the x values
x_steps = (x_max - x_min)/len(y_values)
x_values = np.arange(x_min, x_max,x_steps)
x_values_plot = x_values[1:]
y_values_plot = y_values[1:]
plt.plot(x_values_plot, y_values_plot, label='fit function created sf 2',color='red')
Gamma_fit_created.SF(xmin = x_min, xmax = x_max, label='fit function correct',color='blue')
plt.xlim(0,10000)
plt.ylim(0,1)
#plt.plot(Gamma_fit_created.SF(xmin = 0, xmax = 10000, label='fit function created sf',color='blue'))
plt.legend()
plt.show()
Code
This is my ouput. The functions should be the same, but they are differenasdas
I am running PyTorch implementation of this article (https://arxiv.org/pdf/1604.03650.pdf).
In the article, it says to initialize the deconv layers with bilinear interpolation which is not in the code. it is told that if in deconvolution, we are scaling the data by factor S, the initial weights are defined as:
enter image description here
Does anyone know how can I implement it?
This is the neural network model designed based on the article:
In another word, I don't know how to initialization the deconvolution layers (for example deconv1 layer in this code).
import torch
import torch.nn as nn
import numpy as np
import torchvision
import torch.nn.functional as F
cfg = [64, 128, 256, 512, 512]
class Deep3d(nn.Module):
def __init__(self, in_channels=3, out_channels=3, device=torch.device('cpu')):
super(Deep3d, self).__init__()
self.device = device
vgg16 = torchvision.models.vgg16_bn(pretrained=True)
modules = []
layer = []
for l in vgg16.features:
if isinstance(l, nn.MaxPool2d):
layer.append(l)
modules.append(layer)
layer = []
else:
layer.append(l)
scale = 1
deconv = []
layer = []
for m in range(len(modules)):
layer.append(nn.Conv2d(cfg[m], cfg[m], kernel_size=3, stride=1, padding=True))
layer.append(nn.ReLU(inplace=True))
layer.append(nn.Conv2d(cfg[m], cfg[m], kernel_size=3, stride=1, padding=True))
layer.append(nn.ReLU(inplace=True))
if(m==0):
layer.append(nn.ConvTranspose2d(cfg[m], 65, kernel_size=1, stride=1, padding=(0,0)))
else:
scale *=2
layer.append(nn.ConvTranspose2d(cfg[m], 65, kernel_size=scale*2, stride=scale, padding=(scale//2, scale//2)))
deconv.append(layer) # add blocks of layers to deconv part of the network
layer = []
self.module_1 = nn.Sequential(*modules[0])
self.module_2 = nn.Sequential(*modules[1])
self.module_3 = nn.Sequential(*modules[2])
self.module_4 = nn.Sequential(*modules[3])
self.module_5 = nn.Sequential(*modules[4])
self.deconv_1 = nn.Sequential(*deconv[0])
self.deconv_2 = nn.Sequential(*deconv[1])
self.deconv_3 = nn.Sequential(*deconv[2])
self.deconv_4 = nn.Sequential(*deconv[3])
self.deconv_5 = nn.Sequential(*deconv[4])
self.linear_module = nn.Sequential(*[nn.Linear(15360,4096), # hyperparam choice
nn.ReLU(inplace=True),
nn.Dropout(p=0.5),
nn.Linear(4096,1950)]) # 1950=65(disparity range)*10*3(10*3 is feature map size)
self.deconv_6 = nn.Sequential(*[nn.ConvTranspose2d(65,65,kernel_size=scale*2,stride=scale,padding=(scale//2,scale//2))])
self.upconv_final = nn.Sequential(*[nn.ConvTranspose2d(65,65,kernel_size=(4,4),stride=2,padding=(1,1)),
nn.ReLU(inplace=True),
nn.Conv2d(65,65,kernel_size=(3,3),stride=1,padding=(1,1)),
nn.Softmax(dim=1)])
for block in [self.deconv_1,self.deconv_2,self.deconv_3,self.deconv_4,self.deconv_5,self.deconv_6,self.linear_module,self.upconv_final]:
for m in block:
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, 0, 0.01)
nn.init.constant_(m.bias, 0)
def forward(self, orig_x, x):
x_copy = orig_x
pred = []
out_1 = self.module_1(x)
out_2 = self.module_2(out_1)
out_3 = self.module_3(out_2)
out_4 = self.module_4(out_3)
out_5 = self.module_5(out_4)
# print(out_5.shape)
out_5_flatten = out_5.view(x_copy.shape[0],-1)
out_6 = self.linear_module(out_5_flatten)
p1 = self.deconv_1(out_1)
p2 = self.deconv_2(out_2)
p3 = self.deconv_3(out_3)
p4 = self.deconv_4(out_4)
p5 = self.deconv_5(out_5)
# print(p5.shape)
p6 = self.deconv_6(out_6.view(x_copy.shape[0],65,3,10))
pred.append(p1)
pred.append(p2)
pred.append(p3)
pred.append(p4)
pred.append(p5)
pred.append(p6)
out = torch.zeros(pred[0].shape).to(self.device)
for p in pred:
out = torch.add(out, p)
out = self.upconv_final(out) # to be elt wise multiplied with shifted left views
out = F.interpolate(out,scale_factor=4,mode='bilinear') # upscale to match left input size
new_right_image = torch.zeros(x_copy.size()).to(self.device)
stacked_shifted_view = None
stacked_out = None
for depth_map_idx in range(-33,32):
shifted_input_view = torch.zeros(x_copy.size()).to(self.device)
if depth_map_idx<0:
shifted_input_view[:,:,:,:depth_map_idx] = x_copy[:,:,:,-depth_map_idx:]
elif depth_map_idx==0:
shifted_input_view = x_copy
else:
shifted_input_view[:,:,:,depth_map_idx:] = x_copy[:,:,:,:-depth_map_idx]
if stacked_shifted_view is None:
stacked_shifted_view = shifted_input_view.unsqueeze(1)
else:
stacked_shifted_view = torch.cat((stacked_shifted_view,shifted_input_view.unsqueeze(1)),dim=1)
if stacked_out is None:
stacked_out = out[:,depth_map_idx+33:depth_map_idx+34,:,:].unsqueeze(1)
else:
stacked_out = torch.cat((stacked_out,out[:,depth_map_idx+33:depth_map_idx+34,:,:].unsqueeze(1)),dim=1)
softmaxed_stacked_shifted_view = stacked_shifted_view
mult_soft_shift_out = torch.mul(stacked_out,softmaxed_stacked_shifted_view)
final_rt_image = torch.sum(mult_soft_shift_out,dim=1)
return final_rt_image
# if(__name__=='__main__'):
# vgg16 = torchvision.models.vgg16(pretrained=True)
# model = Deep3d().to(torch.device('cpu'))
# out = model(torch.randn(10,3,384,1280),torch.randn(10,3,96,320))
I am trying to run the following example from the Bokeh docs in a Jupyter notebook as opposed to through the Bokeh server, however I can't figure out what to change in order for this to work? Right now I simply get a blank output. I feel like it should be easy and I'm just missing something...Here is the code from the Bokeh docs.
import numpy as np
from bokeh.models import BoxSelectTool, LassoSelectTool, Paragraph
from bokeh.plotting import figure, hplot, vplot
# create three normal population samples with different parameters
x1 = np.random.normal(loc=5.0, size=400) * 100
y1 = np.random.normal(loc=10.0, size=400) * 10
x2 = np.random.normal(loc=5.0, size=800) * 50
y2 = np.random.normal(loc=5.0, size=800) * 10
x3 = np.random.normal(loc=55.0, size=200) * 10
y3 = np.random.normal(loc=4.0, size=200) * 10
x = np.concatenate((x1, x2, x3))
y = np.concatenate((y1, y2, y3))
TOOLS="pan,wheel_zoom,box_select,lasso_select"
# create the scatter plot
p = figure(tools=TOOLS, plot_width=600, plot_height=600, title=None, min_border=10, min_border_left=50)
r = p.scatter(x, y, size=3, color="#3A5785", alpha=0.6)
p.select(BoxSelectTool).select_every_mousemove = False
p.select(LassoSelectTool).select_every_mousemove = False
# create the horizontal histogram
hhist, hedges = np.histogram(x, bins=20)
hzeros = np.zeros(len(hedges)-1)
hmax = max(hhist)*1.1
LINE_ARGS = dict(color="#3A5785", line_color=None)
ph = figure(toolbar_location=None, plot_width=p.plot_width, plot_height=200, x_range=p.x_range,
y_range=(-hmax, hmax), title=None, min_border=10, min_border_left=50)
ph.xgrid.grid_line_color = None
ph.quad(bottom=0, left=hedges[:-1], right=hedges[1:], top=hhist, color="white", line_color="#3A5785")
hh1 = ph.quad(bottom=0, left=hedges[:-1], right=hedges[1:], top=hzeros, alpha=0.5, **LINE_ARGS)
hh2 = ph.quad(bottom=0, left=hedges[:-1], right=hedges[1:], top=hzeros, alpha=0.1, **LINE_ARGS)
# create the vertical histogram
vhist, vedges = np.histogram(y, bins=20)
vzeros = np.zeros(len(vedges)-1)
vmax = max(vhist)*1.1
th = 42 # need to adjust for toolbar height, unfortunately
pv = figure(toolbar_location=None, plot_width=200, plot_height=p.plot_height+th-10, x_range=(-vmax, vmax),
y_range=p.y_range, title=None, min_border=10, min_border_top=th)
pv.ygrid.grid_line_color = None
pv.xaxis.major_label_orientation = -3.14/2
pv.quad(left=0, bottom=vedges[:-1], top=vedges[1:], right=vhist, color="white", line_color="#3A5785")
vh1 = pv.quad(left=0, bottom=vedges[:-1], top=vedges[1:], right=vzeros, alpha=0.5, **LINE_ARGS)
vh2 = pv.quad(left=0, bottom=vedges[:-1], top=vedges[1:], right=vzeros, alpha=0.1, **LINE_ARGS)
pv.min_border_top = 80
pv.min_border_left = 0
ph.min_border_top = 10
ph.min_border_right = 10
p.min_border_right = 10
layout = vplot(hplot(p, pv), hplot(ph, Paragraph(width=200)), width=800, height=800)
def update(attr, old, new):
inds = np.array(new['1d']['indices'])
if len(inds) == 0 or len(inds) == len(x):
hhist1, hhist2 = hzeros, hzeros
vhist1, vhist2 = vzeros, vzeros
else:
neg_inds = np.ones_like(x, dtype=np.bool)
neg_inds[inds] = False
hhist1, _ = np.histogram(x[inds], bins=hedges)
vhist1, _ = np.histogram(y[inds], bins=vedges)
hhist2, _ = np.histogram(x[neg_inds], bins=hedges)
vhist2, _ = np.histogram(y[neg_inds], bins=vedges)
hh1.data_source.data["top"] = hhist1
hh2.data_source.data["top"] = -hhist2
vh1.data_source.data["right"] = vhist1
vh2.data_source.data["right"] = -vhist2
r.data_source.on_change('selected', update)
Thanks in advance!
You have to run the output_notebook command first to set notebook operation (https://docs.bokeh.org/en/latest/docs/user_guide/notebook.html), then use the show command
tl;dr
from bokeh.io import output_notebook, show
output_notebook()
... make plots and stuff ...
show(plots)