Claroja

Bagging + 决策树 = 随机森林AdaBoost + 决策树 = 提升树gradientBoost + 决策树 = 梯度提升树Bagging和Boosting的区别：1）样本选择上：Bagging：训练集是在原始集中有放回选取的，从原始集中选出的各轮训练集之间是独立的。Boosting：每一轮的训练集不变，只是训练集中每个样例在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整。2）样例权重：Bagging：使用均匀取样，每个样例的权重相等Boosting：根据错误率不断

Bagging 和 Boosting 都使用 Bootstrappingbooststraping：是一种有放回的抽样方法1.采用重抽样技术从原始样本中抽取一定数量的样本2.根据抽出的样本计算统计量T。3.重复上述N次（一般大于1000），得到统计量T。4.计算上述N个统计量T的样本方差，得到统计量的方差。允许模型或算法更好地理解存在于其中的偏差、方差和特征。Bootstrapping 同样适用倾向于过拟合的小数据集。参考：https://www.jianshu.com/p/369e3f4

Bagging (bootstrap aggregating)即套袋法大多数提到使用 Bagging 算法的论文或文章都会引用 Leo Breiman，他曾经写过一篇论文《Bagging Predictors》（1996）Bagging 的作用是降低只在训练数据上准确率较高的模型的方差——这种情况也叫作过拟合。主要作用是降低方差，即减少过拟合。1.从原始样本集中抽取训练集。每轮从原始样本集中使用Bootstraping的方法抽取n个训练样本（在训练集中，有些样本可能被多次抽取到，而有些样本可能一

Boosting基本思想按照监督机器学习算法的模式，希望L(y,F(x))L(y,F(x))L(y,F(x))尽可能的小。从传动的平方损失函数就是：希望对所有样本，min1N∑i=1N(yi−F(xi))2min\frac{1}{N}\sum^N_{i=1}(y_i-F(x_i))^2minN1​∑i=1N​(yi​−F(xi​))2但是因为F(x)F(x)F(x)是由多个含有不同参数的弱分类器组成，无法像传统的梯度下降的形式进行直接优化，所以：我们的目标是最小化min(y−F(x))2min(y

GBDT算法流程为：2.1 ：求之前分类器损失函数的负梯度作为本次弱分类器需要拟合的输出2.2：对回归树的学习，一般选择CART TREE（分类回归树），对应的叶节点区域为w，CART TREE生成就用平方误差最小化2.3：在叶结点区域上损失函数最小，求弱分类器权重2.4：合成新的分类器参考：https://www.jianshu.com/p/b0e147de75e6GBDT（Gradient Boosting Decision Tree）梯度提升树AdaBoost算法是模型为加法模型，.

1.传统的GBDT为了控制树的复杂度常常会对树的叶子个数加正则项进行控制, XGBoost不仅仅对于树中的叶子节点的个数进行控制,与此同时还对每个叶子节点的分数加入正则.即:传统的GBDT的损失函数:1.xgboost 中的基学习器除了可以是CART（gbtree）也可以是线性分类器（gblinear）。2.xgboost在目标函数中显示的加上了正则化项：3.XGBoost中的导数不是一阶的,是二阶的;4.XGBoost中的剪枝部分在对叶子的个数做惩罚的同时还加入权重的惩罚.换言之,正则项进行了改

adaboost（adaptive boosting），即自适应助推法。Boosting 也需要 Bootstrapping。但是，这里还有一个区别。与 bagging 不同，adaboost 为每个数据样本加权。这意味着一些样本运行的频率比其他样本高。1.当 Boosting 运行在模型中时，它追踪哪些数据样本是成功的，哪些不成功。输出结果分类错误最多的数据集会被赋予更高的权重。即这些数据更加复杂，需要更多次迭代才能恰当地训练模型。2.在实际的分类阶段中，Boosting 处理模型的方式也存在区别

类型支持分裂算法特征类型类别个数ID3分类信息增益离散值多叉树C4.5分类信息增益率离散值、连续值多叉树CART分类、回归基尼系数、均方差离散值、连续值二叉树ID3缺点：1.没有减枝策略，容易过拟合2.信息增益准则对取值数目较多的特征有所偏好3.只能处理离散特征4.没有考虑缺失值C4.5优点：1.引入后减枝策略，避免过拟合2.使用信息增益率作为划分标准，（也可能导致对取值数目较少的特征有所偏好）3.将连续特征离散化4....

参考文献：https://www.cnblogs.com/starfire86/p/5749334.html

one_hotone_hot模型，将每个单词映射到一个V维的向量中，此种V代表词汇的数量，V[i]=1表示当前单词，0表示不是当前单词。如：我爱中国[100010001]\begin{matrix}我\\ 爱\\ 中国\end{matrix}\begin{bmatrix}1 & 0 & 0\\ 0 & 1& 0\\ 0 & 0 & 1\end{bmatrix}我爱中国​⎣⎡​100​010​001​⎦⎤​one_hot编码的问题是

参考：https://github.com/createmomo/CRF-Layer-on-the-Top-of-BiLSTMhttps://createmomo.github.io/2017/09/12/CRF_Layer_on_the_Top_of_BiLSTM_1/https://createmomo.github.io/2017/09/23/CRF_Layer_on_the_Top_of_BiLSTM_2/https://createmomo.github.io/2017/10/08/CRF

# Example of using Sequentialmodel = nn.Sequential( nn.Conv2d(1,20,5), nn.ReLU(), nn.Conv2d(20,64,5), nn.ReLU() )# Example of using Sequential with OrderedDictmodel = nn.Sequential(OrderedDict([

https://www.zhihu.com/question/66782101/answer/579393790

OutlineThe article series will include:Introduction - the general idea of the CRF layer on the top of BiLSTM for named entity recognition tasksA Detailed Example - a toy example to explain how CRF layer works step-by-stepChainer Implementation - a chai

Transformer (2017)和BERT (2018) 加速了NLP的发展。在将预料送入模型前，我们需要对预料进行处理：1.分词（Split the input into smaller chunks）2.向量化（Represent the input as a vector）在训练向量前，我们要先确定好分词的协议(tokenization policy).1）需要有一个庞大的词库（vocabulary）即使学习到了“cat”，但是模型还是辨认不出“cats”。没有将words分割到su

In 2018 we saw the rise of pretraining and finetuning in natural language processing. Large neural networks have been trained on general tasks like language modeling and then fine-tuned for classification tasks. One of the latest milestones in this develop

import osimport sysimport pickleimport pandas as pdimport numpy as npfrom concurrent.futures import ThreadPoolExecutorimport torchimport picklefrom sklearn.preprocessing import LabelEncoderfrom torch.optim import optimizerfrom torch.utils.data im

transformers中大部分模型的输入都是相同的。Input IDsfrom transformers import BertTokenizertokenizer = BertTokenizer.from_pretrained("bert-base-uncased")sequence = "A Titan RTX has 24GB of VRAM"# tokenizer依据它的vocabulary按照一定的算法将seq分割为tokens# RTX是被分割成rt 和 ##x,这是一个分词的算法

API最原始的Bert Model，输出raw hidden-states。是PyTorch torch.nn.Module sub-class.class transformers.BertModel参数描述config (BertConfig)配置对象，初始化配置，并不会载入权重。forward(input_ids=None, attention_mask=None, token_type_ids=None, position_ids=None, head_mask

class transformers.PreTrainedTokenizerClass attributes (overridden by derived classes)属性描述vocab_files_names (Dict[str, str])pretrained_vocab_files_map (Dict[str, Dict[str, str]])max_model_input_sizes (Dict[str, Optinal[int]])pretra

import numpy as npimport pandas as pdfrom sklearn.model_selection import train_test_splitfrom sklearn.linear_model import LogisticRegressionimport torchimport transformers as tfstrain_df = pd.read_csv('./data/train.tsv', delimiter='\t', header=None)

应用import torchimport torch.utils.data as Datax = torch.linspace(1, 10, 10)y = torch.linspace(10, 1, 10)torch_dataset = Data.TensorDataset(x, y)torch_dataset[0]APICLASS torch.utils.data.TensorDataset(*tensors: torch.Tensor)每个样本的第一维度会被当成索引

import numpy as npimport pandas as pdfrom sklearn.model_selection import train_test_splitfrom sklearn.linear_model import LogisticRegressionfrom sklearn.model_selection import GridSearchCVfrom sklearn.model_selection import cross_val_scoreimport torc

APIregister_buffer(name: str, tensor: Optional[torch.Tensor], persistent: bool = True) → None注册buffer，表名不是权重参数。比如BatchNorm的running_mean不是parameter，但是他是模型的state。buffers，是持久的和parameters一起保存的。参数描述name (string)name of the buffer. The buffer can

APICLASS torch.nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward=2048, dropout=0.1, activation='relu')TransformerEncoderLayer is made up of self-attn and feedforward network.参数描述d_modelthe number of expected features in the input (r

tokenizing a text is splitting it into words or subwords, which then are converted to ids.分割文本并不像想象的简单。比如我们要分割句子 “Don’t you love ???? Transformers? We sure do.”1）简单的方法是通过空格["Don't", "you", "love", "????", "Transformers?", "We", "sure", "do."]2）将标点符号也

APIclass transformers.PreTrainedTokenizer(**kwargs)参考：https://huggingface.co/transformers/main_classes/tokenizer.html

基本使用主要是使用tokenizer，首先会分割文本成单词(tokens)，然后将这些单词转换为数字。在 pretraining or fine-tuning一个model时，使用from_pretrained()来处理文本from transformers import AutoTokenizertokenizer = AutoTokenizer.from_pretrained('bert-base-cased')encoded_input = tokenizer("Hello, I'm a

transformer架构介绍首先把transformer当成一个黑盒子，输入是一个序列，输出是另外一个序列，如下图：transformer由两部分组成，一个是encoders，另外一个是decoders，两者是相连的。encoders包含了多个encoder，同样dicoders也包含了多个decoder。encoders之间不共享权重，每个encoder又包含了两层：第一层是self-attention层，这一层可以让词语观察整个句子的其他词语第二层是feed-forward neur

1.seq2seqsequence-to-sequence 输入是一个序列(词语，字符，图像特征等)输出是另外一个序列，如下图：应用在翻译中就是输入一个句子再输出一个句子，如下图：这个模型由encoder和decoder组成。encoder处理输入的序列，并形成一个context(是一个向量),然后decoder处理context得到输出序列。encoder和decoder都是RNN。在机器翻译中，同理：我们可以设置context向量的大小。一般都是RNN的hidden units。下

应用>>> rnn = nn.LSTM(10, 20, 2)>>> input = torch.randn(5, 3, 10)>>> h0 = torch.randn(2, 3, 20)>>> c0 = torch.randn(2, 3, 20)>>> output, (hn, cn) = rnn(input, (h0, c0))概念RNN可以看成是一个普通的网络（比如CNN）在时间线上做了多次复制，时

import osimport matplotlib.pyplot as pltimport numpy as npimport torchfrom torch import nnimport torch.optim as optimimport torchvisionfrom torchvision import transforms, models, datasetsimport imageioimport timeimport warningsimport randomimpo

相对alexn 增加了层数，filter变成3*3

池化层参考：https://cs231n.github.io/convolutional-networks/https://www.oreilly.com/radar/visualizing-convolutional-neural-networks/

在使用backward()之前，默认为None，使用之后累加grad1.创建可求导的tensorimport torchx = torch.randn(3,4,requires_grad=True)# x = torch.randn(3,4)# x.requires_grad=True2.可grad的tensor计算得来的tensor也可gradimport torchx = torch.randn(3,4,requires_grad=True)b = torch.randn(3,4,r

# 将模型放入到cuda中device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")model.to(device)# 将输入输出放入到cuda 中inputs = torch.from_numpy(x_train).to(device)labels = torch.from_numpy(y_train).to(device)

取指定维度的数据应用>>> x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])>>> torch.narrow(x, 0, 0, 2) # 第0维度的 0~2tensor([[ 1, 2, 3], [ 4, 5, 6]])>>> torch.narrow(x, 1, 1, 2) # 第1维度的 1~2tensor([[ 2, 3], [ 5, 6]

squeeze的反向操作，增加size=1的维度应用>>> x = torch.tensor([1, 2, 3, 4])>>> torch.unsqueeze(x, 0)tensor([[ 1, 2, 3, 4]])>>> torch.unsqueeze(x, 1)tensor([[ 1], [ 2], [ 3], [ 4]])APItorch.unsqueeze(input, di