def fit(self, x=None, y=None, batch_size=None, epochs=1, validation_data=None, distributed=False, **kwargs ): """ Train the model for a fixed num of epochs Arguments: :param x: Input data. It could be: - a TFDataset object - A Numpy array (or array-like), or a list of arrays (in case the model has multiple inputs). - A dict mapping input names to the corresponding array/tensors, if the model has named inputs. :param y: Target data. Like the input data `x`, It should be consistent with `x` (you cannot have Numpy inputs and tensor targets, or inversely). If `x` is a TFDataset, `y` should not be specified (since targets will be obtained from `x`). :param batch_size: Integer or `None`. Number of samples per gradient update. If `x` is a TFDataset, you do not need to specify batch_size. :param epochs: Integer. Number of epochs to train the model. An epoch is an iteration over the entire `x` and `y` data provided. :param validation_data: Data on which to evaluate the loss and any model metrics at the end of each epoch. The model will not be trained on this data. `validation_data` could be: - tuple `(x_val, y_val)` of Numpy arrays or tensors :param distributed: Boolean. Whether to do prediction in distributed mode or local mode. Default is True. In local mode, x must be a Numpy array. """ if isinstance(x, TFDataset): # todo check arguments assert validation_data is None, "validation_data must be None when " \ "using TFDataset as input, please " \ "use set the validation data in TFDataset" if not x.has_batch: raise ValueError("The batch_size of TFDataset must be " + "specified when used in KerasModel fit.") self._fit_distributed(x, epochs, **kwargs) elif distributed: dataset = TFDataset.from_ndarrays((x, y), val_tensors=validation_data, batch_size=batch_size) self._fit_distributed(dataset, epochs, **kwargs) else: self.model.fit(x=x, y=y, batch_size=batch_size, epochs=epochs, validation_data=validation_data, **kwargs )
def evaluate(self, x=None, y=None, batch_per_thread=None, distributed=False ): """ Evaluate a model on a given dataset :param x: Input data. It could be: - a TFDataset object - A Numpy array (or array-like), or a list of arrays (in case the model has multiple inputs). - A dict mapping input names to the corresponding array/tensors, if the model has named inputs. :param y: Target data. Like the input data `x`, It should be consistent with `x` (you cannot have Numpy inputs and tensor targets, or inversely). If `x` is a TFDataset, `y` should not be specified (since targets will be obtained from `x`). :param batch_per_thread: The default value is 1. When distributed is True,the total batch size is batch_per_thread * rdd.getNumPartitions. When distributed is False the total batch size is batch_per_thread * numOfCores. :param distributed: Boolean. Whether to do prediction in distributed mode or local mode. Default is True. In local mode, x must be a Numpy array. """ if isinstance(x, TFDataset): if not x.has_batch: raise ValueError("The batch_per_thread of TFDataset must be " + "specified when used in KerasModel evaluate.") if isinstance(x, TFNdarrayDataset): x = _standarize_feature_label_dataset(x, self.model) # todo check arguments check_data_compatible(x, self.model, mode="evaluate") return self._evaluate_distributed(x) else: if distributed: dataset = TFDataset.from_ndarrays((x, y), batch_per_thread=-1 if batch_per_thread is None else batch_per_thread ) dataset = _standarize_feature_label_dataset(dataset, self.model) return self._evaluate_distributed(dataset) else: results = self.model.evaluate(x=x, y=y, batch_size=batch_per_thread) results = dict(zip(self.metrics_names, results)) return results