Tag: input_shape[1])

How to build federated_averaging_process from custom federated dataset that loads from CSV file

Post author By Full Stack
Post date January 9, 2021
No Comments on How to build federated_averaging_process from custom federated dataset that loads from CSV file

My problem is a continue to this question How to create federated dataset from a CSV file? i manage to load a federated dataset from a given csv file and load both the train and the test data. My question now is how to reproduce a working example to build an iterative process that performs […]

Tags 'counter': TensorSpec(shape=(None, 'counter'] LABEL_COLUMN = 'value' dataset = tf.data.Dataset.from_tensor_slices( (collections.OrderedDict(client_d, 'counter'] LABEL_COLUMN = 'value' dataset = tf.data.Dataset.from_tensor_slices( (collections.OrderedDict(client_data[features, 'value': TensorSpec(shape=(None, "Value"), ), ] what i miss again? maybe something in the layer sequential here def retrieve_model():, ]) return model, ]) return model def tff_model_fn() -> tff.learning.Model: return tff.learning.from_keras_model( keras_model=ret, 2, 6, 7, activation=tf.nn.relu), as it must specify type information for both inputs to and predictions from the model. You passed input spec {'meas_info': TensorSpec(shape=(, but it received 2 input tensors. Inputs received: [, client_data[LABEL_COLUMN].to_list()) ) global input_spec input_spec = dataset.element_spec dataset = dataset., client_data[LABEL_COLUMN].to_list()) ) global input_spec input_spec = dataset.element_spec dataset = dataset.shuffle(SHUFFLE_, counter: '', create_tf_dataset_for_client_fn=create_tf_dataset_for_client_fn ) example_dataset = train_data.create_tf_dataset_for_client(, create_tf_dataset_for_client_fn=create_tf_dataset_for_client_fn ) test_data = tff.simulation.ClientData.from_clients_and_fn(, delimiter=' ', dirs, dtype=tf.float32, filename)) df_list = [] for file in file_list: df = pd.read_csv(file, files in os.walk(working_dir): file_list = [] for filename in files: if filename.endswith('.csv'):, header=None, index_col='time') df_list.append(df[["value"]]) if df_list: rawdata = pd.concat(df_list) client_ids = d, input_shape[1]), input_spec=example_dataset.element_spec, layers.Dense(1) ]) def retrieve_model(): model = tf.keras.models.Sequential([ tf.keras.layers.LSTM(2, loss=loss_builder(), metrics = iterative_process.next(server_state, metrics=metrics_builder()) iterative_process = tff.learning.build_federated_averaging_process( tff_model_fn, My problem is a continue to this question How to create federated dataset from a CSV file? i manage to load a federated dataset from a given, na_filter=True, na_values=["NIL"], name=None)), name=None)}. thnx to @Zachary Garrett i solve the above error with his help by adding these line of code client_data = df[df['value'] == c, names=["meas_info", Parameters.client_adam_optimizer_fn) server_state = iterative_process.initialize() for round_num in range(Parameters.FLAGS.total_rou, Parameters.server_adam_optimizer_fn, replace=False) sampled_train_data = [ train_data.create_tf_dataset_for_client(client) for client in sampled_c, return_sequences=True, sampled_train_data) train_metrics = metrics['train'] print(metrics) if __name__ == '__main__': app.run(main) def start(, size=Parameters.FLAGS.train_clients_per_round, tf.keras.layers.Activation(tf.nn.softmax), tf.keras.layers.Dense(256, Time, usecols=[1

Mastering Development

How to upload my training data into google for Tensorflow cloud training

Post author By Full Stack
Post date November 30, 2020
No Comments on How to upload my training data into google for Tensorflow cloud training

I want to train my keras model in gcp. My code: this is how I load the dataset dataset = pandas.read_csv(‘USDJPY.fx5.csv’, usecols=[2, 3, 4, 5], engine=’python’) this is how i trigger cloud training job_labels = {"job": "forex-usdjpy", "team": "xxx", "user": "xxx"} tfc.run(requirements_txt="./requirements.txt", job_labels=job_labels, stream_logs=True ) Right before my model, which shouldn’t make much of a […]

Tags "team": "xxx", "user": "xxx"} tfc.run(requirements_txt="./requirements.txt", 3, 4, 4))) model.add(Dropout(0.2)) model.add(Dense(4)) model.compile(loss='mean_squared_error', 5, engine='python') this is how i trigger cloud training job_labels = {"job": "forex-usdjpy", I want to train my keras model in gcp. My code: this is how I load the dataset dataset = pandas.read_csv('USDJPY.fx5.csv', input_shape[1]), job_labels=job_labels, stream_logs=True ) Right before my model, usecols=[2, which shouldn't make much of a difference model = Sequential() model.add(LSTM(4

Mastering Development

Boolean Labels Training with Keras causes the error “Please provide data which shares the same first dimension”

Post author By Full Stack
Post date November 18, 2020
No Comments on Boolean Labels Training with Keras causes the error “Please provide data which shares the same first dimension”

So, here is what I am trying to do. My model has to receive a number of training samples, each a conjunction of Boolean literals (i.e. a vector of 0 or 1s) assigned with a truth value. Learning from the samples, it must be able to receive some test vector and determine its truth value. […]

Tags ..., ), 0, 1) The rest of the code is as follows: import numpy as np from random import randint from sklearn.utils import shuf, 1). Then there is a training label array containing labels for each sample. That is, 1)) #-------- train_labels, 1)) model = Sequential([ Dense(units=16, 1)) scaled_train_samples = scaler.fit_transform(train_samples.reshape(-1, 1] may be either acceptable or not (labeled with 1 or 0.) My training sample array contains 15202 of such vectors. It is an array of size (15, 20) (15202, 20) and the train label array is of size (15202, 20)) train_labels = np.random.randint(2, a vector of 0 and 1s such as V = [1, activation='relu', activation='softmax') ]) model.compile(optimizer=Adam(learning_rate=0.0001), and how can I fix that? Thanks., batch_size=10, Dense from tensorflow.keras.optimizers import Adam from tensorflow.keras.metrics import categorical_crossentropy #Main Code # Randomly genera, Dense(units=2, Dense(units=32, each a conjunction of Boolean literals (i.e. a vector of 0 or 1s) assigned with a truth value. Learning from the samples, epochs=30, for illustration only train_samples = np.random.randint(2, here is what I am trying to do. My model has to receive a number of training samples, input_shape[1]), it must be able to receive some test vector and determine its truth value. More concretely, loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(x=scaled_train_samples, size=(15202, So, the following piece of code print(np.shape(train_samples)) print(type(train_samples)) print(np.shape(train_labels)) print(type(train_labels), train_samples = shuffle(train_labels, train_samples) scaler = MinMaxScaler(feature_range=(0, verbose=2) The final line causes an error: ValueError: Data cardinality is ambiguous: x sizes: 304040 y sizes: 15202 Please provide dat, y=train_labels

Mastering Development

Incremental learning in keras

Post author By Full Stack
Post date September 16, 2020
No Comments on Incremental learning in keras

I am looking for a keras equivalent of scikit-learn’s partial_fit : https://scikit-learn.org/0.15/modules/scaling_strategies.html#incremental-learning for incremental/online learning. I finally found the train_on_batch method but I can’t find an example that shows how to properly implement it in a for loop for a dataset that looks like this : x = np.array([[0.5, 0.7, 0.8]]) # input data y […]

Tags 0.33, 0.6, 0.7)', 0.71]) print(s.shape) in_dim = s.shape out_dim = a.shape model = Sequential() model.add(Dense(100, 0.71]]) # output data Note : this is a multi-output regression my code so far: import keras import numpy as np x = np.array([0.5, 0.77, 0.8]) y = np.array([0.4, 0.8]]) # input data y = np.array([[0.4, 0.88, 1, 3, a) I get this Error: ValueError: Input 0 of layer sequential_28 is incompatible with the layer: expected axis -1 of input shape to have valu, activation="relu")) model.add(Dense(32, activation="relu")) model.add(Dense(6)) model.compile(loss="mse", I am looking for a keras equivalent of scikit-learn's partial_fit : https://scikit-learn.org/0.15/modules/scaling_strategies.html#incremental, input_shape[1]), optimizer="adam") model.train_on_batch(s

Mastering Development

ValueError: Tensor conversion requested dtype int32 for Tensor with dtype float32 – LSTM Implementation( tensorflow 2.0.0)

I am trying to test different types of implementations of LSTM and facing this error in the code while predicting. Tensorflow version – ‘2.0.0’ I am not removing this question as I still need to know what went wrong. Do i always need to worry about having float32 as the datatypes while feeding the models? […]

Tags 1, 1) model = Sequential() model.add(LSTM(50, activation='relu', dtype=int) X=array(X).reshape(20, dtype=int) Y= np.array(Y, I am trying to test different types of implementations of LSTM and facing this error in the code while predicting. Tensorflow version - '2.0, input_shape[1])

Linux Mastering Development

ValueError: Input 0 of layer sequential is incompatible with the layer: expected axis 1 of input shape

Post author By Linux Questions
Post date July 3, 2020
No Comments on ValueError: Input 0 of layer sequential is incompatible with the layer: expected axis 1 of input shape

My code : `import numpy from keras.models import Sequential from keras.layers import Dense,Dropout,Flatten,BatchNormalization,Activation from keras.layers.convolutional import Conv2D,MaxPooling2D from keras.constraints import max_norm from keras.utils import np_utils from keras.datasets import cifar10 #set random seed for the purpose of reproductivty seed = 21 #loading in the data (x_train,y_train),(x_test,y_test) = cifar10.load_data() #normalize the inputs from 0-255 to between 0 […]

Tags -32, 3, Activation from keras.layers.convolutional import Conv2D, activation='relu', BatchNormalization, data_format='channels_first')) model.add(Dropout(0.2)) model.add(BatchNormalization()) model.add(Conv2D(64, Dropout, Flatten, input_shape[1]), MaxPooling2D from keras.constraints import max_norm from keras.utils import np_utils from keras.datasets import cifar10 #set random seed for, My code : `import numpy from keras.models import Sequential from keras.layers import Dense, x_test, y_test) = cifar10.load_data() #normalize the inputs from 0-255 to between 0 and 1 by dividing by 255 x_train=x_train.astype('float32') x_tes, y_train

Mastering Development

Numpy Array Index Error: IndexError: boolean index did not match indexed array along dimension 0; dimension is 16

Post author By Full Stack
Post date June 14, 2020
No Comments on Numpy Array Index Error: IndexError: boolean index did not match indexed array along dimension 0; dimension is 16

the following code throws an error: Traceback (most recent call last): File “training.py”, line 19, in <module> preds = model.predict(x_test, test_df) File “D:\brand\models\lstm_detection_model\lstm_brand_detection.py”, line 46, in predict output = [‘ ‘.join(np.array(token_df[i])[np.array(ind[i])]) for i in range(len(ind))] File “D:\brand\models\lstm_detection_model\lstm_brand_detection.py”, line 46, in <listcomp> output = [‘ ‘.join(np.array(token_df[i])[np.array(ind[i])]) for i in range(len(ind))] IndexError: boolean index did not match […]

Tags _ = _forward(x, _ = K.rnn(_backward_step, _ = K.rnn(_forward_step, -1) def chain_crf_loss(y, -1) y_sparse = K.cast(y_sparse, :, :-1] * mask[:, :-1] y_tp1 = y[:, :-1] y_tp1_mask = mask[:, :], :] gamma_0 = K.zeros_like(alpha_0) initial_states = [gamma_0, :])], :]], :]] last_alpha, 'b_end_constraint': constraints.serialize(self.b_end_constraint) } base_config = super(ChainCRF, 'b_end_regularizer': regularizers.serialize( self.b_end_regularizer), 'b_start_constraint': constraints.serialize( self.b_start_constraint), 'b_start_regularizer': regularizers.serialize( self.b_start_regularizer), 'int32') def _backward_step(gamma_t, 'int32') return sparse_chain_crf_loss(y_sparse, 'int32') y_true = K.squeeze(y_true, 'loss') return method(*args) def sparse_loss(*args): method = getattr(instanceHolder['instance'], 'sparse_loss': sparse_loss}, 'sparse_loss') return method(*args) return {'ChainCRF': ClassWrapper, 'U_constraint': constraints.serialize(self.U_constraint), 'U_regularizer': regularizers.serialize(self.U_regularizer), ), [-1]) flat_indices = y_t * n_classes + y_tp1 U_y_t_tp1 = K.gather(U_flat, [K.expand_dims(y_t, ] def __init__(self, **kwargs) def loss(*args): method = getattr(instanceHolder['instance'], **kwargs): instanceHolder['instance'] = self super(ClassWrapper, **kwargs): super(ChainCRF, *args, 0, 0) _, 0) if mask is not None: mask = K.cast(mask, 0) y_t = batch_gather(gamma_t, 0)] initial_states = [K.expand_dims(K.zeros_like(gamma[:, 0] def _forward(x, 1, 1:] U_flat = K.reshape(U, 1:] U_y_t_tp1 *= y_t_mask * y_tp1_mask energy += K.sum(U_y_t_tp1, 1) if mask is not None: mask = K.cast(mask, 1) y_t = y[:, 2, 2) + energy_matrix_t) return new_states[0], 2) + U_shared inputs = K.concatenate([inputs, 2) energy = K.sum(energy, 2) mask = self._fetch_mask() return sparse_chain_crf_loss(y_true, 2) x *= mask if b_start is not None: mask_r = K.concatenate([K.zeros_like(mask[:, 3) U_shared = U_shared * mask_U inputs = K.expand_dims(x[:, 50))) self.model.add(Dropout(dropout)) self.model.add(Bidirectional(LSTM(units, alpha_0] _, and Z is the normalization constant. The values log(Z) is also called free energy. ''' x = add_boundary_energy(x, anyone is aware of a way to rectify this? Thanks! Edit: Posted the entire LSTM_model file in. This involves model training and then outputti, applied to the end bias b. b_start_constraint: instance of the [constraints](../constraints.md) module, applied to the end bias b. weights: list of Numpy arrays for initializing [U, applied to the start bias b. b_end_constraint: instance of the [constraints](../constraints.md) module, applied to the start bias b. b_end_regularizer: instance of [WeightRegularizer](../regularizers.md) module, applied to the transition weight matrix. b_start_regularizer: instance of [WeightRegularizer] (../regularizer, axis=1, axis=1) else: mask = K.cast(mask, axis=1) end_mask = K.cast(K.greater(mask, axis=1) if b_end is not None: x = K.concatenate([x[:, axis=1) last, axis=1) return energy def sparse_chain_crf_loss(y, axis=1) return mask def _fetch_mask(self): mask = None if self.inbound_nodes: mask = self.inbound_no, axis=1) return preds def evaluate(self, axis=1) return preds This seems to be due to the update in Numpy, axis=1) start_mask = K.cast(K.greater(mask, b_end, b_end_constraint=None, b_end_regularizer=None, b_end. ''' x = add_boundary_energy(x, b_end]. Thus it should be a list of 3 elements of shape [(n_classes, b_end=None, b_start, b_start_constraint=None, b_start_regularizer=None, b_start=None, batch_size) * n_classes + K.flatten(indices) return K.gather(K.flatten(reference), batch_size=batch) def save(self, batch=28): self.model.fit(train_x, boundary energies b_start and b_end, columns=['predictions'])], constraint=self.b_end_constraint) if self.initial_weights is not None: self.set_weights(self.initial_weights), constraint=self.b_start_constraint) self.b_end = self.add_weight(shape=(n_classes, constraint=self.U_constraint) self.b_start = self.add_weight(shape=(n_classes, dropout=0.5, dtype='int32') y *= mask y += -(1 - mask) return y class ChainCRF(Layer): ''' A Linear Chain Conditional Random, epochs=5, epochs=epochs, ey, filepath): self.model.save(filepath) def print_summary(self): print(self.model.summary()) def predict(self, flat_indices) def _backward(gamma, flat_indices) if mask is not None: mask = K.cast(mask, gamma, gamma = _forward(x, go_backwards=True) y = K.reverse(y_rev, i.e. the one that maximizes the value of path_energy. ''' x = add_boundary_energy(x, in output = [' '.join(np.array(token_df[i])[np.array(ind[i])]) for i in range(len(ind))] IndexError: boolean index did not mat, in predict output = [' '.join(np.array(token_df[i])[np.array(ind[i])]) for i in range(len(ind))] File "D:\brand\models\lstm_detection_m, in preds = model.predict(x_test, indices): ref_shape = K.shape(reference) batch_size = ref_shape[0] n_classes = ref_shape[1] flat_indices = K.arange(0, init='glorot_uniform', initial_states, initial_states) return last, initializer='zero', initializer=self.init, Input, input x (with mask), input_shape): assert input_shape and len(input_shape) == 3 return (input_shape[0], input_shape): assert len(input_shape) == 3 n_classes = input_shape[2] n_steps = input_shape[1] assert n_steps, input_shape[1]), input_shape[2]) def compute_mask(self, input_shape=(36, inputs, InputSpec def path_energy(y, it adds the start boundary energy b_start (resp. end boundary energy b_end on the start (resp. end) elements and multiplies the mask., it computes the loss function of a Linear Chain Conditional Random Field: loss(y, K.floatx()), K.floatx()) mask = K.expand_dims(mask, K.floatx()) mask_U = K.expand_dims(K.expand_dims(mask[:, K.floatx()) x = x + end_mask * b_end return x def viterbi_decode(x, K.floatx()) x = x + start_mask * b_start if b_end is not None: mask_l = K.concatenate([mask[:, K.floatx()) y_t_mask = mask[:, K.max(B, K.zeros_like(inputs[:, K.zeros_like(mask[:, lambda B: [K.cast(K.argmax(B, lambda B: [K.logsumexp(B, line 19, line 46, loss = loss, loss(y, mask, mask_l), mask_r), mask) alpha_0 = x[:, mask) def add_boundary_energy(x, mask) def free_energy0(x, mask) def get_config(self): config = { 'init': initializers.serialize(self.init), mask) def path_energy0(y, mask) def sparse_loss(self, mask) energy -= free_energy0(x, mask) energy = path_energy0(y, mask) nb_classes = self.input_spec[0].shape[2] y_pred_one_hot = K.one_hot(y_pred, mask) return free_energy0(x, mask) return K.expand_dims(-energy, mask) return last_alpha[:, mask) return path_energy0(y, mask) return y def free_energy(x, mask) y = _backward(gamma, mask): ''' Backward recurrence of the linear chain crf. ''' gamma = K.cast(gamma, mask=None): ''' Calculates the energy of a tag path y for a given input x (with mask), mask=None): ''' Computes efficiently the sum of all path energies for input x, mask=None): ''' Computes the best tag sequence y for a given input x, mask=None): ''' Forward recurrence of the linear chain crf. ''' def _forward_step(energy_matrix_t, mask=None): ''' Free energy without boundary potential handling. ''' initial_states = [x[:, mask=None): ''' Given the observations x, mask=None): ''' Given the true sparsely encoded tag sequence y, mask=None): ''' Path energy without boundary potential handling. ''' n_classes = K.shape(x)[2] y_one_hot = K.one_hot(y, mask=None): ''' Variant of sparse_chain_crf_loss but with one-hot encoded tags y. ''' y_sparse = K.argmax(y, mask=None): if mask is not None: return K.any(mask, mask=None): y_pred = viterbi_decode(x, metrics=['categorical_accuracy']) def fit(self, n_classes), n_classes) energy = K.sum(x * y_one_hot, n_classes))] self.U = self.add_weight(shape=(n_classes, n_steps, name='b_end', name='b_start', name='U', nb_classes) return K.in_train_phase(x, needed for loading a persisted model. ''' instanceHolder = {'instance': None} class ClassWrapper(ChainCRF): def __init__, new_states U_shared = K.expand_dims(K.expand_dims(U, optimizer=adam, or a Theano function (see: [initializers](../initializers.md)). U_regularizer: instance of [WeightRegularizer](../regularizers.md), pd.DataFrame(output, post training. import numpy as np import pandas as pd from nltk import word_tokenize from keras.layers import Dense from keras.layers import, reduce_step, regularizer=self.b_end_regularizer, regularizer=self.b_start_regularizer, regularizer=self.U_regularizer, return_sequences=True, return_sequences=True))) self.model.add(Dropout(dropout)) self.model.add(TimeDistributed(Dense(3))) self.model.add(Dr, self.b_end, self.b_start, self.U, self).__init__(**kwargs) self.init = initializers.get(init) self.U_regularizer = regularizers.get(U_regularizer) self, self).__init__(*args, self).get_config() return dict(list(base_config.items()) + list(config.items())) def create_custom_objects(): ''' Returns th, shape=[None, states): alpha_tm1 = states[-1] new_states = reduce_step(K.expand_dims(alpha_tm1, states): y_tm1 = K.squeeze(states[0], test_df) File "D:\brand\models\lstm_detection_model\lstm_brand_detection.py", test_df=None): token_df = test_df.apply(word_tokenize) ind = self.model.predict(test_x, test_x, test_y): y_pred = self.model.predict(test_x, the following code throws an error: Traceback (most recent call last): File "training.py", train_x, train_y, transition energies U, transition energies U and boundary energies b_start, U, U_constraint=None, U_regularizer=None, units=150): self.model = Sequential() self.model.add(Bidirectional(LSTM(units, values, values def batch_gather(reference, verbose=0).argmax(axis=-1) ind = [[z for z in obs if z!=2] for obs in ind] ind = [[False if elem == 0 else True for elem in o, verbose=0).argmax(axis=-1) ind = [[z for z in obs if z!=2] for obs in ind] ind = [[False if elem == 0 else True for elem in obs] for, verbose=0).argmax(axis=-1) y_test = test_y.argmax(axis=-1) acc = [np.array_equal(y_pred[i], weights=None, when runs over all possible tag sequences. ''' x = add_boundary_energy(x, where P(y|x) = exp(E(y, which is imputed into the BiLSTM Model: from __future__ import absolute_import from keras import backend as K from keras import initializers, X, x) + log(Z) Here, x) = - E(y, x) = NNL(P(y|x)), x) is the tag path energy, x)) / Z. So, y_pred, y_pred_one_hot) def loss(self, y_pred): ''' Linear Chain Conditional Random Field loss function with sparse tag sequences. ''' y_tru, y_pred): ''' Linear Chain Conditional Random Field loss function. ''' mask = self._fetch_mask() retur, y_rev, y_test[i]) for i in range(len(y_pred))].count(True) / len(y_pred) return acc Crf_Layer, y_tm1) return y_t, y_true

Artificial Intelligence (AI) Mastering Development

How to implement a LSTM (classification) with multiple labels per input?

Post author By Jessica Alba
Post date April 8, 2020
No Comments on How to implement a LSTM (classification) with multiple labels per input?

I would like to develop a LSTM because I have a variable input matrix. I am zero padding to a specific length of 800. However, I am not sure of how to classify a certain situation when each input matrix has multiple labels inside. {0,1,2} Data shape (250,800,4) x_train(150,800,4) y_train(150,800,1) x_test(100,800,4) y_test(100,800,1) How to proceed […]

Artificial Intelligence (AI) Mastering Development

How can I implement a 1D CNN in front of my LSTM network

Post author By Jessica Alba
Post date April 2, 2020
No Comments on How can I implement a 1D CNN in front of my LSTM network

At the moment I reshape my X_train like this: X_train = input.reshape(1,1,12) model = Sequential() model.add(LSTM(100,input_shape=(1, 12))) model.add(Dense(100, activation=’relu’)) model.add(Dropout(0.5)) model.add(Dense(9, activation=’sigmoid’)) But now I am thinking of implementing a 1D CNN in front of this LSTM layer. Does anybody know how this should be done?

Tags 1, 12) model = Sequential() model.add(LSTM(100, 12))) model.add(Dense(100, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(9, activation='sigmoid')) But now I am thinking of implementing a 1D CNN in front of this LSTM layer. Does anybody know how this should be done, At the moment I reshape my X_train like this: X_train = input.reshape(1, input_shape[1])

Mastering Development

Triplet Loss with “static” anchor: model with shared layers gives different embeddings of the same image in the batch

Post author By Full Stack
Post date March 17, 2020
No Comments on Triplet Loss with “static” anchor: model with shared layers gives different embeddings of the same image in the batch

I’m playing with the concept of Triplet Loss in Keras 2.3.1 and Tensorflow 2.1.0. I’m trying to implement a loss function where the anchor image is the same for all the triplets. The idea is to train the model to recognize hand-drawn images of the anchor through triplet loss. Code is inspired by: https://github.com/AdrianUng/keras-triplet-loss-mnist/blob/master/Triplet_loss_KERAS_semi_hard_from_TF.ipynb def […]

Tags :1] labels = tf.cast(labels, :int(embeddings.shape[1]/2)] #embedding of a hand-drawn image im_embeggings_np = im_embeddings.numpy() anchor_emb = embeddings[:, (len(x_test), (len(x_train), ), #custom loss function, 1:] im_embeddings = embeddings[:, 1) im_template = im_template.astype('float32') im_template /= 255 im_template = np.reshape(im_template, 1)) im_template_train = np.array([im_template] * len(x_train)) #each image is paired with the anchor im_template_test = np.array([im_templat, 1)) x_test = np.reshape(x_test, activation='relu')(x) x = Dropout(0.1)(x) x = Dense(128, activation='relu')(x) x = Dropout(0.1)(x) x = Dense(embedding_size)(x) base_network = Model(inputs=input_image, all the values of the embedding vectors of the anchor image are different. Why is that? Am I missing something?, anchor_embedding), anchor_embedding]) # concatenating the labels + embeddings of images and anchor # Defining a model with inputs (images, and I want to use that in the following way: def triplet_loss_adapted_from_tf(y_true, and then use that to compute the triplet loss (d(a, batch_size=batch_size, constant_anchor, cv2.IMREAD_GRAYSCALE) input_shape = (im_template.shape[0], dtype='int32') embeddings = y_pred[:, dummy_gt_val)) What I want to do is to calculate the distance between the embeddings of a positive and negative image w.r.t. the embedding o, embedding_size + 1)) dummy_gt_val = np.zeros((len(x_val), embedding_size + 1)) H = model.fit( x=[x_train, embedding_size) input_images = Input(shape=input_shape, embedding_size): """ Base network to be shared (eq. to feature extraction). """ input_image = Input(shape=image_input_shape), epochs=epochs, I'm playing with the concept of Triplet Loss in Keras 2.3.1 and Tensorflow 2.1.0. I'm trying to implement a loss function where the anchor im, im_template_test, im_template_train, im_template.shape[1], image_embedding, images_embeddings, input_anchor, input_labels], input_shape) # The data, input_shape[0], input_shape[1]), int(embeddings.shape[1]/2):] #embeddings of the anchor anchor_emb_np = anchor_emb.numpy() #etc etc... What I'm expecting is anchor_emb, label) and the output is (label, labels) and outputs (labels_plus_embeddings) model = Model(inputs=[input_images, n) with a being a constant). The input of the network is therefore (train_image, name='anchor') ## input layer for anchors images_embeddings = base_network([input_images]) # output of network -> embeddings anchor_, name='input_image') # input layer for images input_labels = Input(shape=(1, name='input_label') # input layer for labels input_anchor = Input(shape=input_shape, outputs=labels_plus_embeddings) # train session opt = Adam(lr=0.0001) model.compile(loss=triplet_loss_adapted_from_tf, outputs=x) plot_model(base_network, p) and d(a, see next optimizer=opt) # Uses 'dummy' embeddings + dummy gt labels. Will be removed as soon as loaded, show_layer_names=True) return base_network batch_size = 48 epochs = 25 train_flag = True embedding_size = 16 im_template = cv2.imread(", show_shapes=True, since they refer to the same input (the template image) and are computed bt the same network with the same weights. But this is not what happ, split between train and test sets (x_train, the other half is different drawings. Labels are simply '0'and '1' x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_tr, to free memory dummy_gt_train = np.zeros((len(x_train), to_file='base_network.png', validation_data=(x_val, x_test, y_pred): del y_true margin = 1. labels = y_pred[:, y_test) = load_images(input_shape) #dataset is all hand-drawn images. Half of them are drawings of the template, y_train, y_val), y=dummy_gt_train