震惊！ “深度学习”都在学习什么

常见的机器学习分类算法

俗话说三个臭皮匠胜过诸葛亮 这里面 集成学习 就是将单一的算法 弱弱结合

算法融合 用投票给特征值加权重 

AdaBoost 集成学习算法

通过迭代训练一系列弱分类器，给予分类错误样本更高权重，使得后续弱分类器更关注这些样本，然后将这些弱分类器线性组合成强分类器，提高整体分类性能。

（一）投票机制

投票是一种直观且常用的算法融合策略。在多分类问题中，假设有多个分类器对同一数据进行分类判断。每个分类器都 “投出” 自己认为正确的类别，最后得票最多的类别就被确定为最终分类结果。比如在一个判断水果种类的任务中，有 5 个分类器，其中 3 个认为图像中的水果是苹果，1 个认为是橙子，1 个认为是香蕉，那么最终结果就是苹果。这种方式简单直接，能快速整合多个模型的意见。

（二）给特征值加权重

给特征值加权重则更为精细和复杂。不同的特征在模型的判断中具有不同的重要性，通过为每个特征分配合适的权重，可以让模型更关注关键特征，从而提升性能。例如在预测房价的模型中，房屋面积、房间数量、地理位置等都是重要特征，但地理位置可能对房价的影响更大。此时，就可以给地理位置特征赋予较高的权重，让模型在学习和预测过程中，对这一特征给予更多的 “关注” 。在实际操作中，确定权重的过程往往借助一些优化算法，通过不断调整权重，使模型在训练数据上的表现达到最优

kN近邻分类

KNN 属于有监督学习算法。其核心思想是：如果一个样本在特征空间中的 k 个最相似（即特征空间中距离最近）的样本中的大多数属于某一个类别，则该样本也属于这个类别。

决策树算法

决策树：通过递归分割特征空间构建决策树模型进行分类 。从根节点开始，依据特征测试结果将实例分配到子节点，递归操作直至叶节点，从而完成分类，可处理数值型和标称型数据，常用于客户分类、信用评分等。

随机森林：属于 Bagging 集成学习，对数据集有放回随机采样且随机选择特征，组合多个决策树来提高预测性能，适用于分类和回归任务，尤其是大数据场景

贝叶斯算法

朴素贝叶斯：基于贝叶斯定理，假设特征间相互独立，通过先验概率和条件概率计算分类的概率，选取概率大的情况进行分类。常用于文本分类、垃圾邮件检测等标称型数据处理。

逻辑回归： 基于统计的算法

虽带有 “回归” 二字，但实际是用于二分类任务的线性分类模型，通过 sigmoid 函数将线性组合转为概率，以此进行分类，如垃圾邮件检测、疾病诊断等场景。

支持向量机（SVM）5支持向量机算法

监督式学习方法，核心是构造分割面（超平面）将数据分离，在线性可分时寻找最优分类超平面，可处理数值型和标称型数据，应用于图像分类、文本分类、生物信息学等领域。

分类器

Softmax 分类器是一种常用的多分类算法

sigmoid 分类器是一种常用的二分类算法

 Sigmoid 函数在机器学习中也有广泛应用，特别是在二分类问题中，常与逻辑回归结合使用。

文本分析

1. TF - IDF（Term Frequency - Inverse Document Frequency）

作用

TF - IDF 是一种用于信息检索与文本挖掘的常用加权技术。它衡量一个词在文档中的重要性，综合考虑了词在当前文档中的出现频率（TF）和在整个文档集合中的稀有程度（IDF）。一个词在某个文档中出现频率高，同时在其他文档中出现频率低，那么这个词对该文档的代表性就强，其 TF - IDF 值就高。

转换形式

给定一个文档集合，TF - IDF 会将每个文档转换为一个向量，向量的每个维度对应一个词，向量的值就是该词在文档中的 TF - IDF 值。例如，对于一个包含 1000 个不同词的文档集合，每个文档会被转换为一个 1000 维的向量。

应用场景

• 信息检索：在搜索引擎中，TF - IDF 可以用来评估查询词与文档的相关性，帮助用户找到最相关的文档。

• 文本分类：作为特征提取方法，将文本转换为向量后输入到分类模型中，帮助模型区分不同类别的文本。

• 关键词提取：通过计算每个词的 TF - IDF 值，找出文档中的关键词。

2. Tokenizer

作用

Tokenizer 是一个分词器，主要用于将文本拆分成一个个的词（或标记，token），并将这些词转换为数字表示。在深度学习中，神经网络通常只能处理数字输入，因此需要将文本数据转换为数字序列。Tokenizer 可以构建词汇表，并将每个词映射到一个唯一的整数索引。

转换形式

输入是文本数据，输出是整数序列。例如，输入文本 "This is a test"，经过 Tokenizer 处理后可能转换为 [1, 2, 3, 4]，其中每个数字对应词汇表中的一个词。

应用场景

• 深度学习模型输入准备：在训练基于神经网络的文本分类、情感分析、机器翻译等模型时，需要将文本数据转换为模型可以接受的数字序列。

• 文本预处理：在进行其他 NLP 任务之前，先对文本进行分词和编码，方便后续处理。

3. Word2Vec

作用

Word2Vec 是一种用于学习词向量表示的模型，它可以将每个词映射到一个低维的向量空间中，使得语义相近的词在向量空间中距离较近。通过学习词的上下文信息，Word2Vec 能够捕捉到词之间的语义关系。

转换形式

输入是文本数据，输出是每个词对应的向量。例如，在一个 300 维的词向量空间中，每个词都被表示为一个 300 维的向量。这些向量可以用于表示整个文本，例如将一个句子中的所有词向量相加或求平均得到句子的向量表示。

应用场景

• 文本相似度计算：通过计算词向量或句子向量之间的相似度，判断文本之间的语义相似度。

• 文本分类和聚类：将词向量或句子向量作为特征输入到分类或聚类模型中，帮助模型更好地理解文本的语义信息。

• 机器翻译：在翻译过程中，利用词向量的语义信息提高翻译的准确性。

  
  # 读取数据
  df = pd.read_csv('文件名.csv')
  '''如果数据里面没有列名 加上 header=None'''
  df = pd.read_csv('文件名.tsv', sep='\t')
  '''多文件合并 手动添加标签'''
  df1 = pd.read_csv('文件名1.csv', header=None, sep='\n\t')
  df2 = pd.read_csv('文件名2.csv', header=None, sep='\n\t')
  df3 = pd.read_csv('文件名3.csv', header=None, sep='\n\t')
  df1['label'] = 0
  df2['label'] = 1
  df3['label'] = 2
  
  df = pd.concat([df1, df2, df3])
  
  '''txt '''
  
  df = pd.read_csv('文件名.txt', header=None, sep='\n\t')
  
  # 查看
  df.info()
  
  # 类不平衡处理
  print(df['标签'].value_counts())
  df1 = df[df['标签'] == '类别1'].sample('最少类别数量')
  df2 = df[df['标签'] == '类别2'].sample('最少类别数量')
  df3 = df[df['标签'] == '类别3'].sample('最少类别数量')
  
  df = pd.concat([df1, df2, df3])
  
  '''如果类别不是以数字形式出现的 做标签化'''
  from sklearn.preprocessing import LabelEncoder
  
  y = LabelEncoder().fit_transform(df['标签'])
  
  # 独热
  from tensorflow.keras import utils
  
  y_one = utils.to_categorical(y, 'y的类别数量')
  
  # 文本数据处理
  
  import jieba
  
  x = df['文本']
  x = x.map(lambda s: jieba.lcut(s))
  x = x.map(lambda s: [i for i in s if len(i) > 1])  # >*<  o r z  -.-!!     
   
  '''停用词'''
  stopwords = pd.read_csv('停用词库.txt', header=None, sep='\n\t')
  stopwords = ['停用词1', '停用词2', '停用词3', '....']
  x = x.map(lambda s: [i for i in s if i not in stopwords])
  # x = x.map(lambda s:' '.join(s))
  # 文本数据替换
  import re
  
  
  # 定义替换函数--去除标点符号和数字
  def fun(s):
      result = re.sub(f'[^\w\s]', '', str(s))
      result = re.sub(f'[\d]', '', result)
      return result
  
  
  x = x.map(fun)
  
  # 高频词处理
  from collections import Counter
  
  h = ' '.join(x).split()
  count = Counter(h)
  # 词频最高的前十个
  l = count.most_common(10)
  
  x = x.map(lambda s: [i for i in s if i not in l])
  x = x.map(lambda s: ' '.join(s))
  
  # 循环方式处理了词频
  '''
  cout = {}
  for i in x:
      for j in i:
          if count.get(j) == None:
              count[j] = 1
          else:
              count[j] += 1
  h = sorted(count.items(), key=lambda s: s[1])
  print(h)
  stopwords = ['高频词1', '高频词2', '高频词3', '高频词4', '...']
  x = x.map(lambda s: [i for i in s if i not in stopwords])
  x = x.map(lambda s: ' '.join(s))
  '''
  # 绘制词云图
  s = ''
  for i in x:
      s += i + ' '
  from wordcloud import WordCloud
  import matplotlib.pyplot as plt
  
  wd = WordCloud()
  wd.generate(s)
  plt.imshow(wd)
  plt.show()
  
  # 词性分析
  
  import jieba.posseg as posg
  
  f = ''
  for i in x:
      f += i + ' '
  
  cixing = posg.lcut(f)
  
  print(cixing)
  '''筛选名词'''
  mingci = ''
  for i, j in cixing:
      # ci, cixing = i
      if j == 'n':
          mingci += i + ' '
  
  from gensim.models import Word2Vec
  import logging
  from gensim.models.word2vec import logger, LineSentence
  
  
  # word2vec
  def fun():
      # b.设置输出日志
      logging.basicConfig(level=logging.INFO)
      logger.info('running')
      # b.把语料变成句子集合
      sen = LineSentence('train.txt')
      # c.训练word2vec模型
      model = Word2Vec(sen, vector_size=100)
      # d.保存word2vec模型
      model.save('1.model')
  
  
  with open('train.txt', 'w', encoding='utf8') as f:
      for i in x:
          f.write(i + '\n')
  fun()
  
  # 词转向量
  # 一般用在机器学习
  from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
  
  tfidf = TfidfVectorizer()
  x_tfidf = tfidf.fit_transform(x)
  
  tf = CountVectorizer()
  x_tf = tf.fit_transform(x)
  
  from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score
  
  X_train, X_test, y_train, y_test = train_test_split('x_tfidf 或 x_tf', y)
  
  from sklearn.linear_model import LogisticRegression
  from sklearn.svm import SVC
  from sklearn.ensemble import RandomForestClassifier
  from sklearn.naive_bayes import MultinomialNB
  
  lo = LogisticRegression()
  svc = SVC(probability=True)
  rfc = RandomForestClassifier()
  mnb = MultinomialNB()
  
  gmodel = GridSearchCV('lo/svc/rfc/mnb', param_grid={'C/n_estimators/alpha': []}, cv=5)
  gmodel.fit(X_train, y_train)
  
  lo = LogisticRegression(C=gmodel.best_params_['C'])
  lo.fit(X_train, y_train)
  svc = SVC(C=gmodel.best_params_['C'], probability=True)
  svc.fit(X_train, y_train)
  rfc = RandomForestClassifier(nestimators=gmodel.best_params_['n_estimators'])
  rfc.fit(X_train, y_train)
  mnb = MultinomialNB(alpha=gmodel.best_params_['alpha'])
  mnb.fit(X_train, y_train)
  
  lo.predict(X_test)
  svc.predict(X_test)
  rfc.predict(X_test)
  mnb.predict(X_test)
  
  # 交叉验证
  l = [lo, svc, rfc]
  l1 = []
  for i in l:
      l1.append(cross_val_score(i, X_train, y_train, cv=5).mean())
  plt.bar(['lo', 'svc', 'rfc'], l1)
  plt.show()
  
  # 深度学习进行词转向量
  from tensorflow.keras.preprocessing.text import Tokenizer
  from tensorflow.keras.preprocessing import sequence
  
  token = Tokenizer(4000)
  token.fit_on_texts(x)
  print(token.word_counts)
  print(token.word_index)
  seq = token.texts_to_sequences(x)
  seq_pad = sequence.pad_sequences(seq, maxlen=64)
  
  # 9.构建模型
  # a设置词汇表大小
  input_dim = 4001
  # b设定词嵌入维度
  out_put = 100
  # c设定LSTM层单元数
  lstm = 120
  # d创建序列对象
  from tensorflow.keras import models, layers, losses, optimizers, activations, metrics
  
  model = models.Sequential()
  # e设置嵌入层
  model.add(layers.Embedding(input_dim=input_dim, output_dim=out_put, input_length=64))
  # f定义lstm网络
  model.add(layers.LSTM(lstm))
  # model.add(layers.SimpleRNN(lstm))
  # model.add(layers.GRU(lstm))
  model.add(layers.Dense(units=1, activation=activations.sigmoid))
  '''
  units=1 由标签种类决定，如果二分类问题，y没有独热就写1，独热了就写2
  多分类 有多少类别，就写多少类别，activation=activations.softmax
  '''
  # 全链接 三层全链接
  model.add(layers.Dense(units=100, input_dim=64, activation=activations.relu))
  model.add(layers.Dropout(0.2))  # 随机选择20个神经元不计入当次计算
  model.add(layers.Dense(units=50, activation=activations.relu))
  model.add(layers.Dropout(0.2))
  # print(len(np.unique(y)))
  model.add(layers.Dense(units=1, activation=activations.sigmoid))
  '''
  units=1 由标签种类决定，如果二分类问题，y没有独热就写1，独热了就写2
  多分类 有多少类别，就写多少类别，activation=activations.softmax
  '''
  # 10.模型编译
  model.compile(optimizer=optimizers.Adam(), loss=losses.binary_crossentropy, metrics='acc')
  '''
  二分类：用 binary_crossentrop
  多分类：用 sparse_categorical_crossentropy y没独热的情况下
  '''
  # 12.打印模型结构
  model.summary()
  # 12.训练模型
  model.fit(seq_pad, y, epochs=10, validation_split=0.2, batch_size=10)
  '''
  验证集：
  validation_data:必须传入指定验证集，一般情况会使用测试集进行验证（X_test,y_test)
  validation_split: 将前面传入的数据按照一定比例提取出来当作验证集  0.2 
  
  将数据按批次传入进行训练
  batch_size：将现有数据集切分成一定批次数，按批次传入训练
  
  '''
  # 13.保存模型
  model.save('1.h5')
  
  # 预测
  # 加载预测数据
  '''根据题目要求来'''
  # 分词处理
  s = '''这是一段样本'''
  s = jieba.lcut(s)
  s = [i for i in s if len(i) > 1]
  s = [i for i in s if i not in stopwords]
  
  # 词转向量
  seq = token.texts_to_sequences(x)
  seq_pad = sequence.pad_sequences(seq, maxlen=64)
  
  # 预测
  y_pre = model.predict_classes(seq_pad)
  
  # 保存
  pd.DataFrame(y_pre).to_csv('1.csv')
  
  ['', '', '']