精华内容
下载资源
问答
  • min_weight_fraction_leaf:基于权重的剪枝参数 有了权重之后,样本量就不再是单纯地记录数目,而是受输入的权重影响了;min_weight_ fraction_leaf 将比参数 min_samples_leaf 更少偏向主导类。 如果样本是...

    刚刚使用SKLearn学习机器学习进行数据分析,分享一些概念和想法,希望可以大家一起讨论,如果理解或者表达有不准确的地方,请多多指点,不吝赐教,非常感谢~~

    本文将继续介绍sklearn的决策树模块的其他参数

    涉及决策树其他参数:
    请转至《DecisionTreeClassifier的criterion参数 与 使用红酒数据集创建一个树)》:https://blog.csdn.net/weixin_42969619/article/details/98884082
    以及《sklearn的DecisionTreeClassifier的 random_state & splitter 参数》:
    https://blog.csdn.net/weixin_42969619/article/details/99301017
    以及《sklearn的DecisionTreeClassifier的5个剪枝参数》:


    • DecisionTreeClassifier及重要参数:

    class sklearn.tree.DecisionTreeClassifier (criterion=’gini’, splitter=’best’, max_depth=None,
    min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None,
    random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None,
    class_weight=None, presort=False)

    1. class_weight:平衡样本标签比例

    默认None,即函数自动给与数据集中的所有标签相同的权重。
    样本不平衡是指在一组数据集中,标签的一类天生占有很大的比例。分类结果就会受样本比例的影响,因此我们要使用class_weight参数对样本标签进行一定的均衡,给少量的标签更多的权重,让模型更偏向少数类,向捕获少数类的方向建模。

    1. min_weight_fraction_leaf:基于权重的剪枝参数

    有了权重之后,样本量就不再是单纯地记录数目,而是受输入的权重影响了;min_weight_
    fraction_leaf 将比参数 min_samples_leaf 更少偏向主导类。
    如果样本是加权的,则使用基于权重的预修剪标准来更容易优化树结构,这确保叶节点至少包含样本权重的总和的一小部分。

    展开全文
  • RR报文解析(二) fraction lost

    千次阅读 2017-06-06 14:26:01
    这节我们看下RR报文的fraction lost字段,它占8位,RFC_3550中对他的解释为: The sender of the receiver report estimates the fraction of the RTP data packets from source SSRC_n that it assumes to be lost...

    先附上RR报文的图:
    这里写图片描述

    这节我们看下RR报文的fraction lost字段,它占8位,RFC_3550中对他的解释为:
    The sender of the receiver report estimates the fraction of the RTP data packets from source SSRC_n that it assumes to be lost since it sent the previous SR or RR packet.

    翻译过来大概是:RR报文的发送者估计的,自从上一次发送SR或RR报文后,它从SSRC_n 源端接收到的RTP包的丢包率。

    我们注意到它占8位,不难猜出,真实的丢包率是个小数,它由fraction lost字段除以256得到。

    下面我们看下,计算平均丢包率的代码:

      void RtcpBandwidthObserverImpl::OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks,
                                        int64_t rtt,
                                        int64_t now_ms) override {
        if (report_blocks.empty())
          return;
    
        int fraction_lost_aggregate = 0;
        int total_number_of_packets = 0;
    
        // Compute the a weighted average of the fraction loss from all report
        // blocks.
        for (ReportBlockList::const_iterator it = report_blocks.begin();
            it != report_blocks.end(); ++it) {
          std::map<uint32_t, uint32_t>::iterator seq_num_it =
              ssrc_to_last_received_extended_high_seq_num_.find(it->sourceSSRC);
    
          int number_of_packets = 0;
          if (seq_num_it != ssrc_to_last_received_extended_high_seq_num_.end())
            number_of_packets = it->extendedHighSeqNum -  //当前接收到的rtp最高序列号减上一次的最高序列号,得到应该发送的rtp的数量
                seq_num_it->second;
    
          fraction_lost_aggregate += number_of_packets * it->fractionLost;
          total_number_of_packets += number_of_packets;
    
          // Update last received for this SSRC.
          ssrc_to_last_received_extended_high_seq_num_[it->sourceSSRC] =
              it->extendedHighSeqNum;
        }
        if (total_number_of_packets == 0)
          fraction_lost_aggregate = 0;
        else
          fraction_lost_aggregate  = (fraction_lost_aggregate +    //得到的fraction_lost_aggregate其实是平均丢帧率*256, 为何要加上total_number_of_packets / 2,至今不是很明白
              total_number_of_packets / 2) / total_number_of_packets;
        if (fraction_lost_aggregate > 255)   
          return;
    
        owner_->OnReceivedRtcpReceiverReport(fraction_lost_aggregate, rtt,
                                             total_number_of_packets, now_ms);
      }

    为了理解,假设先后收到了3个RR报文,每次接收到的number_of_packets为n1, n2, n3, 每次的fractionLost为f1, f2, f3, 则最后计算出来的fraction_lost_aggregate 为:
    (n1*f1 + n2*f2 + n3*f3 + (n1 + n2 + n3) / 2) / (n1 + n2 + n3).

    其实我不太明白为什么要加上(n1 + n2 + n3) / 2, 正常情况下应该是:
    (n1*f1 + n2*f2 + n3*f3) / (n1 + n2 + n3).

    可能是为了防止结果被四舍五入吧。

    最后结论,可以认为fraction_lost_aggregate 为平均丢包率 * 256, 因为丢包率小于1,所以结果不能大于256.

    然后,还没完,得到fraction_lost_aggregate 后,它调用了owner_->OnReceivedRtcpReceiverReport(fraction_lost_aggregate, rtt,
    total_number_of_packets, now_ms);

    void BitrateControllerImpl::OnReceivedRtcpReceiverReport(
        uint8_t fraction_loss,
        int64_t rtt,
        int number_of_packets,
        int64_t now_ms) {
      {
        rtc::CritScope cs(&critsect_);
        bandwidth_estimation_.UpdateReceiverBlock(fraction_loss, rtt,
                                                  number_of_packets, now_ms);
      }
      MaybeTriggerOnNetworkChanged();
    }

    bandwidth_estimation_是SendSideBandwidthEstimation类,它是估计发送码率的重要类,看下UpdateReceiverBlock函数:

    void SendSideBandwidthEstimation::UpdateReceiverBlock(uint8_t fraction_loss,
                                                          int64_t rtt,
                                                          int number_of_packets,
                                                          int64_t now_ms) {
      if (first_report_time_ms_ == -1)
        first_report_time_ms_ = now_ms;
    
      // Update RTT.
      last_round_trip_time_ms_ = rtt;
    
      // Check sequence number diff and weight loss report
      if (number_of_packets > 0) {
        // Calculate number of lost packets.
        const int num_lost_packets_Q8 = fraction_loss * number_of_packets;
        // Accumulate reports.
        lost_packets_since_last_loss_update_Q8_ += num_lost_packets_Q8;
        expected_packets_since_last_loss_update_ += number_of_packets;
    
        // Don't generate a loss rate until it can be based on enough packets.
        if (expected_packets_since_last_loss_update_ < kLimitNumPackets)
          return;
    
        has_decreased_since_last_fraction_loss_ = false;
        last_fraction_loss_ = lost_packets_since_last_loss_update_Q8_ /   //主要在这里,得出last_fraction_loss_
                              expected_packets_since_last_loss_update_;
    
        // Reset accumulators.
        lost_packets_since_last_loss_update_Q8_ = 0;
        expected_packets_since_last_loss_update_ = 0;
      }
      time_last_receiver_block_ms_ = now_ms;
      UpdateEstimate(now_ms);    //估算码率!!!
      UpdateUmaStats(now_ms, rtt, (fraction_loss * number_of_packets) >> 8);
    }
    展开全文
  • class_weight和sample_weight 1、class_weight 对训练集中的每个类别加一个权重,如果是大类别样本多那么可以设置低的权重,反之可以设置大的权重值 2、sample_weight 对每个样本加权中,思路与上面类似。样本多的...

    在机器学习或者深度学习中,经常会遇到正负样本不平衡问题,尤其是广告、push等场景,正负样本严重不平衡。常规的就是上采样和下采样。

    这里介绍Keras中的两个参数

    class_weight和sample_weight

    1、class_weight 对训练集中的每个类别加一个权重,如果是大类别样本多那么可以设置低的权重,反之可以设置大的权重值

    2、sample_weight 对每个样本加权中,思路与上面类似。样本多的类别样本权重低

    例如 model.fit(class_weight={0:1.,1:100.0},,,) 其中Keras也可以直接设置为model.fit(class_weight='auto',,,)

    需要注意的是:

    1.使用class_weight就会改变loss范围,这样可能会导致训练的稳定性。当Optimizer中的step_size与梯度的大小相关时,将会出现问题。而类似Adam等优化器则不受影响。另外,使用class_weight后的模型的loss大小不能和不使用时做比较

    2、也可以直接使用Keras中的‘auto’这样自动识别权重大小。

    下面是摘要的代码

    def fit(self,
            x=None,
            y=None,
            batch_size=None,
            epochs=1,
            verbose=1,
            callbacks=None,
            validation_split=0.,
            validation_data=None,
            shuffle=True,
            class_weight=None,
            sample_weight=None,
            initial_epoch=0,
            steps_per_epoch=None,
            validation_steps=None,
            validation_freq=1,
            max_queue_size=10,
            workers=1,
            use_multiprocessing=False,
            **kwargs):
      """Trains the model for a fixed number of epochs (iterations on a dataset).
    
      Arguments:
          x: Input data. It could be:
            - A Numpy array (or array-like), or a list of arrays
              (in case the model has multiple inputs).
            - A TensorFlow tensor, or a list of tensors
              (in case the model has multiple inputs).
            - A dict mapping input names to the corresponding array/tensors,
              if the model has named inputs.
            - A `tf.data` dataset. Should return a tuple
              of either `(inputs, targets)` or
              `(inputs, targets, sample_weights)`.
            - A generator or `keras.utils.Sequence` returning `(inputs, targets)`
              or `(inputs, targets, sample weights)`.
          y: Target data. Like the input data `x`,
            it could be either Numpy array(s) or TensorFlow tensor(s).
            It should be consistent with `x` (you cannot have Numpy inputs and
            tensor targets, or inversely). If `x` is a dataset, generator,
            or `keras.utils.Sequence` instance, `y` should
            not be specified (since targets will be obtained from `x`).
          batch_size: Integer or `None`.
              Number of samples per gradient update.
              If unspecified, `batch_size` will default to 32.
              Do not specify the `batch_size` if your data is in the
              form of symbolic tensors, datasets,
              generators, or `keras.utils.Sequence` instances (since they generate
              batches).
          epochs: Integer. Number of epochs to train the model.
              An epoch is an iteration over the entire `x` and `y`
              data provided.
              Note that in conjunction with `initial_epoch`,
              `epochs` is to be understood as "final epoch".
              The model is not trained for a number of iterations
              given by `epochs`, but merely until the epoch
              of index `epochs` is reached.
          verbose: 0, 1, or 2. Verbosity mode.
              0 = silent, 1 = progress bar, 2 = one line per epoch.
              Note that the progress bar is not particularly useful when
              logged to a file, so verbose=2 is recommended when not running
              interactively (eg, in a production environment).
          callbacks: List of `keras.callbacks.Callback` instances.
              List of callbacks to apply during training.
              See `tf.keras.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.
              The validation data is selected from the last samples
              in the `x` and `y` data provided, before shuffling. This argument is
              not supported when `x` is a dataset, generator or
             `keras.utils.Sequence` instance.
          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` will override `validation_split`.
              `validation_data` could be:
                - tuple `(x_val, y_val)` of Numpy arrays or tensors
                - tuple `(x_val, y_val, val_sample_weights)` of Numpy arrays
                - dataset
              For the first two cases, `batch_size` must be provided.
              For the last case, `validation_steps` must be provided.
          shuffle: Boolean (whether to shuffle the training data
              before each epoch) or str (for 'batch').
              'batch' is a special option for dealing with the
              limitations of HDF5 data; it shuffles in batch-sized chunks.
              Has no effect when `steps_per_epoch` is not `None`.
          class_weight: Optional dictionary mapping class indices (integers)
              to a weight (float) value, used for weighting the loss function
              (during training only).
              This can be useful to tell the model to
              "pay more attention" to samples from
              an under-represented class.
          sample_weight: Optional Numpy array of weights for
              the training samples, used for weighting the loss function
              (during training only). You can either pass a flat (1D)
              Numpy array with the same length as the input samples
              (1:1 mapping between weights and samples),
              or 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()`. This argument is not
              supported when `x` is a dataset, generator, or
             `keras.utils.Sequence` instance, instead provide the sample_weights
              as the third element of `x`.
          initial_epoch: Integer.
              Epoch at which to start training
              (useful for resuming a previous training run).
          steps_per_epoch: Integer or `None`.
              Total number of steps (batches of samples)
              before declaring one epoch finished and starting the
              next epoch. When training with input tensors such as
              TensorFlow data tensors, the default `None` is equal to
              the number of samples in your dataset divided by
              the batch size, or 1 if that cannot be determined. If x is a
              `tf.data` dataset, and 'steps_per_epoch'
              is None, the epoch will run until the input dataset is exhausted.
              This argument is not supported with array inputs.
          validation_steps: Only relevant if `validation_data` is provided and
              is a `tf.data` dataset. Total number of steps (batches of
              samples) to draw before stopping when performing validation
              at the end of every epoch. If validation_data is a `tf.data` dataset
              and 'validation_steps' is None, validation
              will run until the `validation_data` dataset is exhausted.
          validation_freq: Only relevant if validation data is provided. Integer
              or `collections_abc.Container` instance (e.g. list, tuple, etc.).
              If an integer, specifies how many training epochs to run before a
              new validation run is performed, e.g. `validation_freq=2` runs
              validation every 2 epochs. If a Container, specifies the epochs on
              which to run validation, e.g. `validation_freq=[1, 2, 10]` runs
              validation at the end of the 1st, 2nd, and 10th epochs.
          max_queue_size: Integer. Used for generator or `keras.utils.Sequence`
              input only. Maximum size for the generator queue.
              If unspecified, `max_queue_size` will default to 10.
          workers: Integer. Used for generator or `keras.utils.Sequence` input
              only. Maximum number of processes to spin up
              when using process-based threading. If unspecified, `workers`
              will default to 1. If 0, will execute the generator on the main
              thread.
          use_multiprocessing: Boolean. Used for generator or
              `keras.utils.Sequence` input only. If `True`, use process-based
              threading. If unspecified, `use_multiprocessing` will default to
              `False`. Note that because this implementation relies on
              multiprocessing, you should not pass non-picklable arguments to
              the generator as they can't be passed easily to children processes.
          **kwargs: Used for backwards compatibility.
    
      Returns:
          A `History` object. Its `History.history` attribute is
          a record of training loss values and metrics values
          at successive epochs, as well as validation loss values
          and validation metrics values (if applicable).
    
      Raises:
          RuntimeError: If the model was never compiled.
          ValueError: In case of mismatch between the provided input data
              and what the model expects.
      """
    展开全文
  • [keras] keras基本功能总结

    千次阅读 多人点赞 2019-04-04 15:13:37
    config.gpu_options.per_process_gpu_memory_fraction = 0.3 set_session(tf.Session(config=config)) 需要注意的是,虽然代码或配置层面设置了对显存占用百分比阈值,但在实际运行中如果达到了这个阈值,程序有...

    自从tensorflow进入2.0时代,之前的程序用2.0的tf跑就会报出一大堆的deprecated warning,要求使用 keras.xx instead...看来tensorflow是铁了心要推keras上正统的宝座,有必要学习一下keras的使用了。

    官方文档:https://keras-cn.readthedocs.io/en/latest/

    参考1,keras callback:https://spaces.ac.cn/archives/5765

    Tensorflow 2.0: models migration and new design:https://pgaleone.eu/tensorflow/gan/2018/11/04/tensorflow-2-models-migration-and-new-design/

    2.0与1.x比较:https://www.tinymind.cn/articles/3844

    参考2:https://blog.csdn.net/sinat_26917383/article/details/72857454

    1-keras思维导图

    1.1-网络结构

    1.2-网络配置

     1.3-预处理

    è¿éåå¾çæè¿°

     1.4-模型的节点信息提取

    # 节点信息提取
    config = model.get_config()  # 把model中的信息,solver.prototxt和train.prototxt信息提取出来
    model = Model.from_config(config)  # 还回去
    # or, for Sequential:
    model = Sequential.from_config(config) # 重构一个新的Model模型,用去其他训练,fine-tuning比较好

    1.5-模型概况查询(包括权重查询)

    # 1、模型概括打印
    model.summary()
    
    # 2、返回代表模型的JSON字符串,仅包含网络结构,不包含权值。可以从JSON字符串中重构原模型:
    from models import model_from_json
    
    json_string = model.to_json()
    model = model_from_json(json_string)
    
    # 3、model.to_yaml:与model.to_json类似,同样可以从产生的YAML字符串中重构模型
    from models import model_from_yaml
    
    yaml_string = model.to_yaml()
    model = model_from_yaml(yaml_string)
    
    # 4、权重获取
    model.get_layer()      #依据层名或下标获得层对象
    model.get_weights()    #返回模型权重张量的列表,类型为numpy array
    model.set_weights()    #从numpy array里将权重载入给模型,要求数组具有与model.get_weights()相同的形状。
    
    # 查看model中Layer的信息
    model.layers 查看layer信息

    1.6-模型保存与加载

    model.save_weights(filepath)
    # 将模型权重保存到指定路径,文件类型是HDF5(后缀是.h5)
    
    model.load_weights(filepath, by_name=False)
    # 从HDF5文件中加载权重到当前模型中, 默认情况下模型的结构将保持不变。
    # 如果想将权重载入不同的模型(有些层相同)中,则设置by_name=True,只有名字匹配的层才会载入权重

    2-keras+GPU

    本节来源于:深度学习theano/tensorflow多显卡多人使用问题集(参见:Limit the resource usage for tensorflow backend · Issue #1538 · fchollet/keras · GitHub
    在使用keras时候会出现总是占满GPU显存的情况,可以通过重设backend的GPU占用情况来进行调节。

    import tensorflow as tf
    from keras.backend.tensorflow_backend import set_session
    config = tf.ConfigProto()
    config.gpu_options.per_process_gpu_memory_fraction = 0.3
    set_session(tf.Session(config=config))

    需要注意的是,虽然代码或配置层面设置了对显存占用百分比阈值,但在实际运行中如果达到了这个阈值,程序有需要的话还是会突破这个阈值。换而言之如果跑在一个大数据集上还是会用到更多的显存。以上的显存限制仅仅为了在跑小数据集时避免对显存的浪费而已。

    3-keras模型训练与保存

    filepath = 'model-ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5'
    checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')
    # fit model
    model.fit(x, y, epochs=20, verbose=2, callbacks=[checkpoint], validation_data=(x, y))

    save_best_only打开之后,会如下:

    ETA: 3s - loss: 0.5820Epoch 00017: val_loss did not improve

    如果val_loss 提高了就会保存,没有提高就不会保存。

    4-keras+tensorboard

    RUN = RUN + 1 if 'RUN' in locals() else 1   # locals() 函数会以字典类型返回当前位置的全部局部变量。
    
    LOG_DIR = model_save_path + '/training_logs/run{}'.format(RUN)
    LOG_FILE_PATH = LOG_DIR + '/checkpoint-{epoch:02d}-{val_loss:.4f}.hdf5'   # 模型Log文件以及.h5模型文件存放地址
    
    tensorboard = TensorBoard(log_dir=LOG_DIR, write_images=True)
    checkpoint = ModelCheckpoint(filepath=LOG_FILE_PATH, monitor='val_loss', verbose=1, save_best_only=True)
    early_stopping = EarlyStopping(monitor='val_loss', patience=5, verbose=1)
    
    history = model.fit_generator(generator=gen.generate(True), steps_per_epoch=int(gen.train_batches / 4),
                                      validation_data=gen.generate(False), validation_steps=int(gen.val_batches / 4),
                                      epochs=EPOCHS, verbose=1, callbacks=[tensorboard, checkpoint, early_stopping])

    都是在回调函数中起作用:

    EarlyStopping patience:

    1. 当earlystop被激活(如发现loss相比上一个epoch训练没有下降),则经过patience个epoch后停止训练。
    2. mode:‘auto’,‘min’,‘max’之一,在min模式下,如果检测值停止下降则中止训练。在max模式下,当检测值不再上升则停止训练。

    模型检查点ModelCheckpoint:

    1. save_best_only:当设置为True时,将只保存在验证集上性能最好的模型
    2.  mode:‘auto’,‘min’,‘max’之一,在save_best_only=True时决定性能最佳模型的评判准则,例如,当监测值为val_acc时,模式应为max,当检测值为val_loss时,模式应为min。在auto模式下,评价准则由被监测值的名字自动推断。
    3. save_weights_only:若设置为True,则只保存模型权重,否则将保存整个模型(包括模型结构,配置信息等)
    4. period:CheckPoint之间的间隔的epoch数

    可视化tensorboard write_images: 是否将模型权重以图片的形式可视化

    其他内容可参考keras中文文档

    5-keras的Sequential模型

    序贯模型是函数式模型的简略版,为最简单的线性、从头到尾的结构顺序,不分叉。

    Sequential模型的基本组件

    一般需要:

    • 1、model.add,添加层;
    • 2、model.compile,模型训练的BP模式设置;
    • 3、model.fit,模型训练参数设置 + 训练;
    • 4、模型评估
    • 5、模型预测

    1. add:添加层——train_val.prototxt

    add(self, layer)
    
    # 譬如:
    model.add(Dense(32, activation='relu', input_dim=100))
    model.add(Dropout(0.25))

    add里面只有层layer的内容,当然在序贯式里面,也可以model.add(other_model)加载另外模型,在函数式里面就不太一样,详见函数式。

    2、compile 训练模式——solver.prototxt文件

    compile(self, optimizer, loss, metrics=None, sample_weight_mode=None)

    其中:
    optimizer: 字符串(预定义优化器名)或优化器对象,参考优化器
    loss: 字符串(预定义损失函数名)或目标函数,参考损失函数
    metrics: 列表,包含评估模型在训练和测试时的网络性能的指标,典型用法是metrics=[‘accuracy’]
    sample_weight_mode:如果你需要按时间步为样本赋权(2D权矩阵),将该值设为“temporal”。
    默认为“None”,代表按样本赋权(1D权)。在下面fit函数的解释中有相关的参考内容。
    kwargs: 使用TensorFlow作为后端请忽略该参数,若使用Theano作为后端,kwargs的值将会传递给 K.function

    注意:
    模型在使用前必须编译,否则在调用fit或evaluate时会抛出异常。

    3、fit 模型训练参数+训练——train.sh+soler.prototxt(部分)

    fit(self, x, y, batch_size=32, epochs=10, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0)

    本函数将模型训练nb_epoch轮,其参数有:

    • x:输入数据。如果模型只有一个输入,那么x的类型是numpy
    • array,如果模型有多个输入,那么x的类型应当为list,list的元素是对应于各个输入的numpy array
    • y:标签,numpy array
    • batch_size:整数,指定进行梯度下降时每个batch包含的样本数。训练时一个batch的样本会被计算一次梯度下降,使目标函数优化一步。
    • epochs:整数,训练的轮数,每个epoch会把训练集轮一遍。
    • verbose:日志显示,0为不在标准输出流输出日志信息,1为输出进度条记录,2为每个epoch输出一行记录
    • callbacks:list,其中的元素是keras.callbacks.Callback的对象。这个list中的回调函数将会在训练过程中的适当时机被调用,参考回调函数
    • validation_split:0~1之间的浮点数,用来指定训练集的一定比例数据作为验证集。验证集将不参与训练,并在每个epoch结束后测试的模型的指标,如损失函数、精确度等。注意,validation_split的划分在shuffle之前,因此如果你的数据本身是有序的,需要先手工打乱再指定validation_split,否则可能会出现验证集样本不均匀。
    • validation_data:形式为(X,y)的tuple,是指定的验证集。此参数将覆盖validation_spilt。
    • shuffle:布尔值或字符串,一般为布尔值,表示是否在训练过程中随机打乱输入样本的顺序。若为字符串“batch”,则是用来处理HDF5数据的特殊情况,它将在batch内部将数据打乱。
    • class_weight:字典,将不同的类别映射为不同的权值,该参数用来在训练过程中调整损失函数(只能用于训练)
    • sample_weight:权值的numpy
    • array,用于在训练时调整损失函数(仅用于训练)。可以传递一个1D的与样本等长的向量用于对样本进行1对1的加权,或者在面对时序数据时,传递一个的形式为(samples,sequence_length)的矩阵来为每个时间步上的样本赋不同的权。这种情况下请确定在编译模型时添加了sample_weight_mode=‘temporal’。
    • initial_epoch: 从该参数指定的epoch开始训练,在继续之前的训练时有用。
    • fit函数返回一个History的对象,其History.history属性记录了损失函数和其他指标的数值随epoch变化的情况,如果有验证集的话,也包含了验证集的这些指标变化情况

    注意
    要与之后的fit_generator做区别,两者输入x/y不同。

    4.evaluate 模型评估

    evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None)

    本函数按batch计算在某些输入数据上模型的误差,其参数有:

    • x:输入数据,与fit一样,是numpy array或numpy array的list
    • y:标签,numpy array
    • batch_size:整数,含义同fit的同名参数
    • verbose:含义同fit的同名参数,但只能取0或1
    • sample_weight:numpy array,含义同fit的同名参数
    • 本函数返回一个测试误差的标量值(如果模型没有其他评价指标),或一个标量的list(如果模型还有其他的评价指标)。model.metrics_names将给出list中各个值的含义。

    如果没有特殊说明,以下函数的参数均保持与fit的同名参数相同的含义
    如果没有特殊说明,以下函数的verbose参数(如果有)均只能取0或1

    5 predict 模型评估

    predict(self, x, batch_size=32, verbose=0)
    predict_classes(self, x, batch_size=32, verbose=1)
    predict_proba(self, x, batch_size=32, verbose=1)

    本函数按batch获得输入数据对应的输出,其参数有:

    函数的返回值是预测值的numpy array
    predict_classes:本函数按batch产生输入数据的类别预测结果;
    predict_proba:本函数按batch产生输入数据属于各个类别的概率

    6 on_batch 、batch的结果,检查

    train_on_batch(self, x, y, class_weight=None, sample_weight=None)
    test_on_batch(self, x, y, sample_weight=None)
    predict_on_batch(self, x)
    • train_on_batch:本函数在一个batch的数据上进行一次参数更新,函数返回训练误差的标量值或标量值的list,与evaluate的情形相同。
    • test_on_batch:本函数在一个batch的样本上对模型进行评估,函数的返回与evaluate的情形相同
    • predict_on_batch:本函数在一个batch的样本上对模型进行测试,函数返回模型在一个batch上的预测结果

    7 fit_generator

    #利用Python的生成器,逐个生成数据的batch并进行训练。
    #生成器与模型将并行执行以提高效率。
    #例如,该函数允许我们在CPU上进行实时的数据提升,同时在GPU上进行模型训练
    # 参考链接:http://keras-cn.readthedocs.io/en/latest/models/sequential/

    有了该函数,图像分类训练任务变得很简单。

    fit_generator(self, generator, steps_per_epoch, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, class_weight=None, max_q_size=10, workers=1, pickle_safe=False, initial_epoch=0)
    
    # 案例:
    def generate_arrays_from_file(path):
        while 1:
                f = open(path)
                for line in f:
                    # create Numpy arrays of input data
                    # and labels, from each line in the file
                    x, y = process_line(line)
                    yield (x, y)
            f.close()
    
    model.fit_generator(generate_arrays_from_file('/my_file.txt'),
            samples_per_epoch=10000, epochs=10)

    其他的两个辅助的内容:

    evaluate_generator(self, generator, steps, max_q_size=10, workers=1, pickle_safe=False)
    predict_generator(self, generator, steps, max_q_size=10, workers=1, pickle_safe=False, verbose=0)
    • evaluate_generator:本函数使用一个生成器作为数据源评估模型,生成器应返回与test_on_batch的输入数据相同类型的数据。该函数的参数与fit_generator同名参数含义相同,steps是生成器要返回数据的轮数。
    • predcit_generator:本函数使用一个生成器作为数据源预测模型,生成器应返回与test_on_batch的输入数据相同类型的数据。该函数的参数与fit_generator同名参数含义相同,steps是生成器要返回数据的轮数。

    6-keras的Model模型

    来自keras中文文档:http://keras-cn.readthedocs.io/en/latest/
    比序贯模型要复杂,但是效果很好,可以同时/分阶段输入变量,分阶段输出想要的模型;
    一句话,只要你的模型不是类似VGG一样一条路走到黑的模型,或者你的模型需要多于一个的输出,那么你总应该选择函数式模型。

    不同之处:
    书写结构完全不一致

    函数式模型基本属性与训练流程

    一般需要:

    1. model.layers,添加层信息;
    2. model.compile,模型训练的BP模式设置;
    3. model.fit,模型训练参数设置 + 训练;
    4. evaluate,模型评估;
    5. predict 模型预测

    1 常用Model属性

    model.layers:组成模型图的各个层
    model.inputs:模型的输入张量列表
    model.outputs:模型的输出张量列表
    

    2 compile 训练模式设置——solver.prototxt

    compile(self, optimizer, loss, metrics=None, loss_weights=None, sample_weight_mode=None)

    本函数编译模型以供训练,参数有

    • optimizer:优化器,为预定义优化器名或优化器对象,参考优化器
    • loss:损失函数,为预定义损失函数名或一个目标函数,参考损失函数
    • metrics:列表,包含评估模型在训练和测试时的性能的指标,典型用法是metrics=[‘accuracy’]如果要在多输出模型中为不同的输出指定不同的指标,可像该参数传递一个字典,例如metrics={‘ouput_a’: ‘accuracy’}
    • sample_weight_mode:如果你需要按时间步为样本赋权(2D权矩阵),将该值设为“temporal”。默认为“None”,代表按样本赋权(1D权)。
    • 如果模型有多个输出,可以向该参数传入指定sample_weight_mode的字典或列表。在下面fit函数的解释中有相关的参考内容。

    【Tips】如果你只是载入模型并利用其predict,可以不用进行compile。在Keras中,compile主要完成损失函数和优化器的一些配置,是为训练服务的。predict会在内部进行符号函数的编译工作(通过调用_make_predict_function生成函数)

    3 fit 模型训练参数设置 + 训练

    fit(self, x=None, y=None, batch_size=32, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0)

     

    本函数用以训练模型,参数有:

    • x:输入数据。如果模型只有一个输入,那么x的类型是numpy
    • array,如果模型有多个输入,那么x的类型应当为list,list的元素是对应于各个输入的numpy
    • array。如果模型的每个输入都有名字,则可以传入一个字典,将输入名与其输入数据对应起来。
    • y:标签,numpy array。如果模型有多个输出,可以传入一个numpy
    • array的list。如果模型的输出拥有名字,则可以传入一个字典,将输出名与其标签对应起来。
    • batch_size:整数,指定进行梯度下降时每个batch包含的样本数。训练时一个batch的样本会被计算一次梯度下降,使目标函数优化一步。
    • nb_epoch:整数,训练的轮数,训练数据将会被遍历nb_epoch次。Keras中nb开头的变量均为"number of"的意思
    • verbose:日志显示,0为不在标准输出流输出日志信息,1为输出进度条记录,2为每个epoch输出一行记录
    • callbacks:list,其中的元素是keras.callbacks.Callback的对象。这个list中的回调函数将会在训练过程中的适当时机被调用,参考回调函数
    • validation_split:0~1之间的浮点数,用来指定训练集的一定比例数据作为验证集。验证集将不参与训练,并在每个epoch结束后测试的模型的指标,如损失函数、精确度等。注意,validation_split的划分在shuffle之后,因此如果你的数据本身是有序的,需要先手工打乱再指定validation_split,否则可能会出现验证集样本不均匀。
    • validation_data:形式为(X,y)或(X,y,sample_weights)的tuple,是指定的验证集。此参数将覆盖validation_spilt。
    • shuffle:布尔值,表示是否在训练过程中每个epoch前随机打乱输入样本的顺序。
    • class_weight:字典,将不同的类别映射为不同的权值,该参数用来在训练过程中调整损失函数(只能用于训练)。该参数在处理非平衡的训练数据(某些类的训练样本数很少)时,可以使得损失函数对样本数不足的数据更加关注。
    • sample_weight:权值的numpy
    • array,用于在训练时调整损失函数(仅用于训练)。可以传递一个1D的与样本等长的向量用于对样本进行1对1的加权,或者在面对时序数据时,传递一个的形式为(samples,sequence_length)的矩阵来为每个时间步上的样本赋不同的权。这种情况下请确定在编译模型时添加了sample_weight_mode=‘temporal’。
    • initial_epoch: 从该参数指定的epoch开始训练,在继续之前的训练时有用。
    • 输入数据与规定数据不匹配时会抛出错误

    fit函数返回一个History的对象,其History.history属性记录了损失函数和其他指标的数值随epoch变化的情况,如果有验证集的话,也包含了验证集的这些指标变化情况

    4 evaluate,模型评估

    evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None)
    

    本函数按batch计算在某些输入数据上模型的误差,其参数有:

    • x:输入数据,与fit一样,是numpy array或numpy array的list
    • y:标签,numpy array
    • batch_size:整数,含义同fit的同名参数
    • verbose:含义同fit的同名参数,但只能取0或1
    • sample_weight:numpy array,含义同fit的同名参数
    • 本函数返回一个测试误差的标量值(如果模型没有其他评价指标),或一个标量的list(如果模型还有其他的评价指标)。model.metrics_names将给出list中各个值的含义。

    如果没有特殊说明,以下函数的参数均保持与fit的同名参数相同的含义
    如果没有特殊说明,以下函数的verbose参数(如果有)均只能取0或1

    5 predict 模型预测

    predict(self, x, batch_size=32, verbose=0)

    本函数按batch获得输入数据对应的输出,其参数有:

    函数的返回值是预测值的numpy array

    6 模型检查 on_batch

    train_on_batch(self, x, y, class_weight=None, sample_weight=None)
    test_on_batch(self, x, y, sample_weight=None)
    predict_on_batch(self, x)
    
    • train_on_batch:本函数在一个batch的数据上进行一次参数更新,函数返回训练误差的标量值或标量值的list,与evaluate的情形相同。
    • test_on_batch:本函数在一个batch的样本上对模型进行评估,函数的返回与evaluate的情形相同;
    • predict_on_batch:本函数在一个batch的样本上对模型进行测试,函数返回模型在一个batch上的预测结果

    7 generator

    fit_generator(self, generator, steps_per_epoch, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, class_weight=None, max_q_size=10, workers=1, pickle_safe=False, initial_epoch=0)
    evaluate_generator(self, generator, steps, max_q_size=10, workers=1, pickle_safe=False)
    

     

    展开全文
  • 三、RPN和ROI_heads中的weight设置不一样 如果看源码再细一点可以发现RPN网络中使用边框回归的时候的weight设置是和ROI_heads中的weight不一样的。 首先看一下RPN网络初始化的时候BoxCoder的weight参数设置 class ...
  • In addition to that, each training sample may be given a weight, if user wants the algorithm to pay special attention to certain training samples and adjust the training model accordingly. Also, user...
  • [LightGBM] [Warning] min_sum_hessian_in_leaf is set=0.001, min_child_weight=0.001 will be ignored. Current value: min_sum_hessian_in_leaf=0.001 [LightGBM] [Warning] bagging_fraction is set=0.7,...
  • ohos:weight="1" ohos:text="主页" ohos:text_size="50" > </Button> <Button ohos:id="$+id:main_my_btn" ohos:width="0vp" ohos:height="match_parent" ohos:weight="1" ohos:text="我的...
  • [LightGBM] [Warning] min_sum_hessian_in_leaf is set=0.001, min_child_weight=0.001 will be ignored. Current value: min_sum_hessian_in_leaf=0.001 [LightGBM] [Warning] bagging_fraction is set=0.7,...
  • Given two integers representing the numerator and denominator of a fraction, return the fraction in string format.If the fractional part is repeating, enclose the repeating part in parentheses.For exa
  • 全网目前最全python例子(附源码)

    万次阅读 多人点赞 2019-12-30 14:55:05
    源码 ...告别枯燥,60秒学会一个小例子,系统学习Python,从入门到大师。Python之路已有190个例子: 第零章:感受Python之美 第一章:Python基础 第二章:Python之坑 第三章:Python字符串和正则 第四章:Python文件 ...
  • 如果 feature_fraction 小于 1.0, LightGBM 将会在每次迭代中随机选择部分特征. 例如, 如果设置为 0.8, 将会在每棵树训练之前选择 80% 的特征 可以用来加速训练 可以用来处理过拟合 bagging_...
  • 五个剪枝参数(max_depth,min_samples_split,min_samples_leaf,max_feature,min_impurity_decrease) 1特殊参数(目标权重参数): class_weight & min_weight_fraction_leaf 一个属性:feature_importances_ 四个...
  • { "learning_rate": 0.1, "boosting": 'gbdt', "lambda_l2": 0.1, "max_depth": -1, "num_leaves": 128, "bagging_fraction": 0.8, "feature_fraction": 0.8, "metric": None, "objective": "multiclass", "num_...
  • (8) fraction:百分数。 (9) enum:枚举值。 (10)flag:位或运算。      2.控件的属性定义完了,然后就是要在代码里面获取使用这些属性,看源代码的时候,你会发现系统定义的属性都是通过TypedArray这玩意...
  • 实践练习六

    2018-06-03 16:45:00
    fraction fraction::operator*(const fraction &f1) { int newtop = top * f1.top; int newbottom = bottom * f1.bottom; return fraction(newtop, newbottom); } fraction fraction::operator/(const fraction &...
  • 今天官网上看见了一个对layout_weight的评论(在下面), 还看了这篇博客http://lovezhou.iteye.com/blog/827881 终于基本理解这个属性怎么用了。 个人认为设置layout_weight属性时,若父控件为vertical,应该...
  • boosting_type='gbdt', num_leaves=31, max_depth=-1, learning_rate=0.1, n_estimators=100, subsample_for_bin=200000, objective=None, class_weight=None, min_split_gain=0.0, min_child_weight=0.001...
  • "min_samples_leaf", "min_weight_fraction_leaf", "max_features", "max_leaf_nodes", "min_impurity_decrease", "min_impurity_split", "random_state"), bootstrap=bootstrap, oob_score=oob_score, n_...
  • self).fit(X, _y, sample_weight=sample_weight, init_score=init_score, eval_set=eval_set, eval_names=eval_names, eval_sample_weight=eval_sample_weight, eval_class_weight=eval_class_weight, eval_init_...
  • * @param weight The weight of the new observation. * @param value The value of the new observation. */ public void addSample ( int weight , long value ) { ensureSortedByIndex ( ) ; ...
  • Pool的案例应用 train_dataPool = Pool(data=[[12, 14, 16, 18], [23, 25, 27, 29], [32, 34, 36, 38]], label=[10, 20, 30], weight=[0.1, 0.2, 0.3]) # weight各自权重默认设置为1 Pool源代码解读 class Pool ...
  • sklearn决策树算法总结

    2020-04-08 08:59:31
    min_weight_fraction_leaf 在设置了class_weight以后,如果需要剪枝,就需要搭配min_weight_fraction_leaf这个基于权重的剪枝参数来使用。 1.5 重要接口 分类决策树有四个重要的接口,分别为fit,score,predict,...
  • 最小均方算法(LMS Algorithm)理论及DSP实现

    万次阅读 多人点赞 2013-08-04 21:49:29
    h[i] += lms_prob->weight[j] * lms_prob->x[i*lms_prob->n+j]; /* h(x) */ } if (lms_prob->method == STOCHASTIC) break; /* handle STOCHASTIC */ } for (j=0; j<lms_prob->n; j++) { if (lms_...
  • min_weight_fraction_leaf : float, optional (default=0.) The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal ...
  • min_weight_fraction_leaf : float, optional (default=0.) The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal ...
  • min_weight_fraction_leaf :这个值限制了叶子节点所有样本权重和的最小值,如果小于这个值,则会和兄弟节点一起被剪枝。 默认是0,就是不考虑权重问题。一般来说,如果我们有较多样本有缺失值,或者分类树样本的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,652
精华内容 3,460
关键字:

fractionweight