Xc@@sddlmZddlmZddlZddlZddlZddlZddlZddl Z ddl Z yddl Z Wne k rddl Z nXddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZdeddZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'dddZ(dZ)dZ*ddddZ+de,fdYZ-defdYZ.dS( i(tprint_function(tabsolute_importNi(t Containeri(tbackend(t optimizers(tlosses(tmetrics(tProgbar(t callbacks(t interfacestc C@s|dkr/gtt|D] }d^qSt|trg}x|D]D}||kr~td|dt|n|j||qKWn}t|trt|t|kr|r't |ddr'td|dtt|dtt|dt|d d qt|d krNt j |g}qtd|d tt|d t|d n|}nt |dst d|dt|d d nt|d kr tdtt|dt|j n|g}xXtt|D]D}||} t| j d kr&t j| d } | ||d%krR |,j?d&d'qh |,j?d&d(n|,_@d)S(*siConfigures the model for training. # Arguments optimizer: str (name of optimizer) or optimizer object. See [optimizers](/optimizers). loss: str (name of objective function) or objective function. See [losses](/losses). If the model has multiple outputs, you can use a different loss on each output by passing a dictionary or a list of losses. metrics: list of metrics to be evaluated by the model during training and testing. Typically you will use `metrics=['accuracy']`. To specify different metrics for different outputs of a multi-output model, you could also pass a dictionary, such as `metrics={'output_a': 'accuracy'}`. loss_weights: Optional list or dictionary specifying scalar coefficients (Python floats) to weight the loss contributions of different model outputs. If a list, it is expected to have a 1:1 mapping to the model's outputs. If a tensor, it is expected to map output names (strings) to scalar coefficients. sample_weight_mode: if you need to do timestep-wise sample weighting (2D weights), set this to `"temporal"`. `None` defaults to sample-wise weights (1D). If the model has multiple outputs, you can use a different `sample_weight_mode` on each output by passing a dictionary or a list of modes. **kwargs: when using the Theano backend, these arguments are passed into K.function. Ignored for Tensorflow backend. # Raises ValueError: In case of invalid arguments for `optimizer`, `loss`, `metrics` or `sample_weight_mode`. s#Unknown entry in loss dictionary: "s%". Only expected the following keys: sOutput "s{" missing from loss dictionary. We assume this was done on purpose, and we will not be expecting any data to be passed to "s" during training.t stacklevelisWWhen passing a list as loss, it should have one entry per model outputs. The model has s outputs, but you passed loss=Rog?s+Unknown entry in loss_weights dictionary: "s_When passing a list as loss_weights, it should have one entry per model outputs. The model has s& outputs, but you passed loss_weights=s+Could not interpret loss_weights argument: s - expected a list of dicts.s1Unknown entry in sample_weight_mode dictionary: "s-" missing from sample_weight_modes dictionaryRwRkR#t_sample_weightsiseWhen passing a list as sample_weight_mode, it should have one entry per model outputs. The model has s, outputs, but you passed sample_weight_mode=t_targettsparseRxRIt_losss@The model cannot be compiled because it has no loss to optimize.gc@sTtjdkr0j|jd|}njj|jj|dS(s#Helper function used in loop below.iR!N(RR,t output_layersR#t metrics_namesRtmetrics_tensors(t layer_numt metric_namet metric_tensor(R(s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pyt append_metricstaccuracytaccittheanotkeycS@s|jr|jS|jS(N(R#t auto_name(R8((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pytscS@s|jS(N(R#(R8((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pyRsN(ARR*t optimizerR{RIt loss_weightsRRR,RRtwarningstwarnRRRRtoutputsR tloss_functionsRtt _feed_outputst_feed_output_namest_feed_output_shapest_feed_loss_fnsR tinternal_output_shapest compute_maskR5RRRgt placeholdertsample_weight_modest_feed_sample_weight_modesR6t _feed_targetst is_sparseRxRRRt RuntimeErrorRPRCtmetrics_moduletbinary_accuracytsparse_categorical_crossentropytsparse_categorical_accuracytcategorical_accuracyRvREtsixt iteritemst total_losstsample_weightst_feed_sample_weightst_function_kwargsttrain_functiont test_functiontpredict_functionttrainable_weightsRtsortt_collected_trainable_weights(-RRRIRRR{tkwargsR#Rtlt loss_functionR!Rrtweighted_lossest skip_indicesR$tmaskstloss_weights_listRRtweighttmodeR RRRmRnt weighted_lossR2Rot loss_weightt output_losst loss_tensorRNRROtmetrict output_shapetacc_fnt masked_fnt metric_fntmasked_metric_fnt metric_resultttensorR((Rs4/tmp/pip-build-isqEY4/keras/keras/engine/training.pytcompiles$       &%(        +                                                         &    &           cC@st|dstdn|jdkr|j|j|j}|jrytt j t  ry|t j g7}n|j j |j|j|j}|j|}t j||jg|jd||j|_ndS(NRs,You must compile your model before using it.tupdates(RRRR t _feed_inputsRRtuses_learning_phaseRRgtlearning_phaseRQRt get_updatesRt constraintsRRtfunctionRR(RR5ttraining_updatesR((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pyt_make_train_functions    cC@st|dstdn|jdkr|j|j|j}|jrytt j t  ry|t j g7}nt j ||j g|jd|j|j|_ndS(NRs,You must compile your model before using it.R(RRRR RRRRRRgRRQRRRt state_updatesR(RR5((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pyt_make_test_functions cC@st|dsd|_n|jdkr|jrbttjt rb|jtjg}n |j}t |di}tj ||j d|j ||_ndS(NRRR( RR RRRRgRRQRtgetattrRRR(RR5R((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pyt_make_predict_functions    i idiic C@st} |rN| rNt} |rNtd|djd| djdfqNn|r{t|ddr{|djd}n |}d}tj|}tj|_ tj g|pg|j g}|r|tj g7}ntj |}|pg}t|dr#|j r#|j }n|}|j||ji|d6|d6|d6|d 6| d 6| pkgd 6|jt|_x|D]}| |_qWx>t| |D]-}|j|| d krt||}n| rtjj|nt||}i}xt|D]\}\}}|||!}yGt|d trrt|d ||d g}nt||}Wntk rtdnXi}||d   !  !  cC@st|dstdng}xt|j|jD]k\}} | jdkrm|j|d d q:tt| jddkr|jdq:|j|q:Wt ||j |j dt dd}t ||j|dt dd }t||j} t||j} gt|| | |jD]'\} } }}t| | ||^q+} t||| t||j|j|jr|r|d jd |d krtd t|d jd d qn||| fS(NRsWYou must compile a model before training/testing. Use `model.compile(optimizer, loss)`.RiiRR s model inputs model targetiszIn a stateful network, you should only pass inputs with a number of samples that can be divided by the batch size. Found: s samples(i(RRRRRRERRRR R)t_feed_input_namest_feed_input_shapesRRR3R1RR~RARLtstatefulR RR(RR8R:R2R0RRWRGRtloss_fnRt class_weightstreftswtcwR((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pyt_standardize_user_datas@"       C (gc !K@sd| kr1tjddd| jd}n| rPtdt| n|j||d| d| dtd |\}}}|rxt}t|dkr|\}}d}n:t|d kr|\}}}nt d t||j||d|dtd |\}}}|j |j }|j rgttjt rg|||d g}q|||}n|rd |kod knrt}tt|dd |}t|d|t||}}t|d|t||}}t|d|t||}}|j |j }|j rnttjt rn|||d g}q|||}nt}d}d}|j rttjt r|||d g}n|||}|j|j}|j}g}xpt|D]b\}}|}|j|dkrZ|| j|}|dt|d7}n|j|qW|}|rtj|g|D]}d|^q} ntj|} |j||d|d |d|d|d|d|d|d| d| d|  S(s Trains the model for a fixed number of epochs (iterations on a dataset). # Arguments x: Numpy array of training data, or list of Numpy arrays if the model has multiple inputs. If all inputs in the model are named, you can also pass a dictionary mapping input names to Numpy arrays. y: Numpy array of target data, or list of Numpy arrays if the model has multiple outputs. If all outputs in the model are named, you can also pass a dictionary mapping output names to Numpy arrays. batch_size: integer. Number of samples per gradient update. epochs: integer, the number of times to iterate over the training data arrays. verbose: 0, 1, or 2. Verbosity mode. 0 = silent, 1 = verbose, 2 = one log line per epoch. callbacks: list of callbacks to be called during training. See [callbacks](/callbacks). validation_split: float between 0 and 1: fraction of the training data to be used as validation data. The model will set apart this fraction of the training data, will not train on it, and will evaluate the loss and any model metrics on this data at the end of each epoch. 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. This could be a tuple (x_val, y_val) or a tuple (x_val, y_val, val_sample_weights). shuffle: boolean, whether to shuffle the training data before each epoch. class_weight: optional dictionary mapping class indices (integers) to a weight (float) to apply to the model's loss for the samples from this class during training. This can be useful to tell the model to "pay more attention" to samples from an under-represented class. sample_weight: optional array of the same length as x, containing weights to apply to the model's loss for each sample. In the case of temporal data, you can pass a 2D array with shape (samples, sequence_length), to apply a different weight to every timestep of every sample. In this case you should make sure to specify sample_weight_mode="temporal" in compile(). initial_epoch: epoch at which to start training (useful for resuming a previous training run) # Returns A `History` instance. Its `history` attribute contains all information collected during training. # Raises ValueError: In case of mismatch between the provided input data and what the model expects. tnb_epochs;The `nb_epoch` argument in `fit` has been renamed `epochs`.Ris Unrecognized keyword arguments: R2R0RRWisWhen passing validation_data, it must contain 2 (x_val, y_val) or 3 (x_val, y_val, val_sample_weights) items, however it contains %d itemsgg?iiR!R RRRRR R!RTR"R#N(RRtpopRRRARRRR RRRRRRgRRQReRRRRtcountRRMR2(!RR8R:RWRRRtvalidation_splitRRTR0R2R#RRRtval_xtval_ytval_sample_weighttval_sample_weightsR R!tsplit_atRRRtdeduped_out_labelsR$tlabelt new_labeltdup_idxtnR"((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pytfit(sH        """     -  c C@s|j||d|dtd|\}}}|jrdttjt rd|||dg}n|||}|j|j}|j ||d|d|S(sReturns the loss value & metrics values for the model in test mode. Computation is done in batches. # Arguments x: Numpy array of test data, or list of Numpy arrays if the model has multiple inputs. If all inputs in the model are named, you can also pass a dictionary mapping input names to Numpy arrays. y: Numpy array of target data, or list of Numpy arrays if the model has multiple outputs. If all outputs in the model are named, you can also pass a dictionary mapping output names to Numpy arrays. batch_size: integer. Number of samples per gradient update. verbose: verbosity mode, 0 or 1. sample_weight: Array of weights to weight the contribution of different samples to the loss and metrics. # Returns Scalar test loss (if the model has a single output and no metrics) or list of scalars (if the model has multiple outputs and/or metrics). The attribute `model.metrics_names` will give you the display labels for the scalar outputs. R2RRWgR( RARRRRgRRQRRR( RR8R:RWRR2RRR((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pytevaluates   c C@st||j|jdt}|jr|djd|kr|djd|dkrtdt|djddt|dqn|jrt t j t  r|dg}n|}|j |j}|j||d|d|S( sGenerates output predictions for the input samples. Computation is done in batches. # Arguments x: the input data, as a Numpy array (or list of Numpy arrays if the model has multiple outputs). batch_size: integer. verbose: verbosity mode, 0 or 1. # Returns Numpy array(s) of predictions. # Raises ValueError: In case of mismatch between the provided input data and the model's expectations, or in case a stateful model receives a number of samples that is not a multiple of the batch size. RiszIn a stateful network, you should only pass inputs with a number of samples that can be divided by the batch size. Found: s samples. Batch size: t.gRWR(R)R9R:RR;R RRRRRgRRQRRR8(RR8RWRRR((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pytpredicts    26  c C@s|j||d|d|dt\}}}|jrdttjt rd|||dg}n|||}|j|j|}t |dkr|dS|S(sRuns a single gradient update on a single batch of data. # Arguments x: Numpy array of training data, or list of Numpy arrays if the model has multiple inputs. If all inputs in the model are named, you can also pass a dictionary mapping input names to Numpy arrays. y: Numpy array of target data, or list of Numpy arrays if the model has multiple outputs. If all outputs in the model are named, you can also pass a dictionary mapping output names to Numpy arrays. sample_weight: optional array of the same length as x, containing weights to apply to the model's loss for each sample. In the case of temporal data, you can pass a 2D array with shape (samples, sequence_length), to apply a different weight to every timestep of every sample. In this case you should make sure to specify sample_weight_mode="temporal" in compile(). class_weight: optional dictionary mapping class indices (integers) to a weight (float) to apply to the model's loss for the samples from this class during training. This can be useful to tell the model to "pay more attention" to samples from an under-represented class. # Returns Scalar training loss (if the model has a single output and no metrics) or list of scalars (if the model has multiple outputs and/or metrics). The attribute `model.metrics_names` will give you the display labels for the scalar outputs. R2R0Rg?ii( RARRRRgRRQRRR(RR8R:R2R0RRR((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pyttrain_on_batch&s$  cC@s|j||d|dt\}}}|jr^ttjt r^|||dg}n|||}|j|j|}t |dkr|dS|S(slTest the model on a single batch of samples. # Arguments x: Numpy array of test data, or list of Numpy arrays if the model has multiple inputs. If all inputs in the model are named, you can also pass a dictionary mapping input names to Numpy arrays. y: Numpy array of target data, or list of Numpy arrays if the model has multiple outputs. If all outputs in the model are named, you can also pass a dictionary mapping output names to Numpy arrays. sample_weight: optional array of the same length as x, containing weights to apply to the model's loss for each sample. In the case of temporal data, you can pass a 2D array with shape (samples, sequence_length), to apply a different weight to every timestep of every sample. In this case you should make sure to specify sample_weight_mode="temporal" in compile(). # Returns Scalar test loss (if the model has a single output and no metrics) or list of scalars (if the model has multiple outputs and/or metrics). The attribute `model.metrics_names` will give you the display labels for the scalar outputs. R2Rgii( RARRRRgRRQRRR(RR8R:R2RRR((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pyt test_on_batchYs  cC@st||j|j}|jrGttjt rG|dg}n|}|j|j |}t |dkr|dS|S(sReturns predictions for a single batch of samples. # Arguments x: Input samples, as a Numpy array. # Returns Numpy array(s) of predictions. gii( R)R9R:RRRgRRQRRR(RR8RR((s4/tmp/pip-build-isqEY4/keras/keras/engine/training.pytpredict_on_batchs   i c (C@sd} | }t|}|j|r5|jnt|dpPt|d}|ro| rotdn|j}|g|D]}d|^q}tj|_tj g|pg|jg}|r|tj ddg7}ntj |}t|dr |j r |j }n|}|j ||ji|d 6|d6|d 6|d 6|d 6|j|r | r t|d kr|\}}d}n:t|dkr|\}}}ntdt||j|||\}}}x$|D]}|||g|_qWnd}z1t|d| }|jd| d| t|_x||krU|j|d}d}x||kr*d}x?|jr|jjs|jj}Pqtj| qWt|dstdt|nt|d kr(|\}}d} n:t|dkrL|\}}} ntdt|i}!t |t!r|dj"d}"n<t |t#rt!|j$dj"d}"n |j"d}"||!d<|"|!d<|j%||!|j&||d| d|}#t |#t!s$|#g}#nx't'||#D]\}$}%|%|!|$sL         k /   ) 2 %  % 5 ( R[