德克萨斯大学奥斯汀分校自然语言处理硕士课程汉化版(第一周) - 自然语言处理介绍和线性分类

自然语言处理介绍和线性分类

  • 1. 自然语言处理介绍
  • 2. 线性二分类
  • 3. 情感分析和基础特征提取
    • 3.1. 情感分析
    • 3.2. 特征提取
    • 3.3. 文本预处理
  • 4. 学习的基础-梯度下降算法
  • 5. 感知机
  • 6. 逻辑回归
  • 7. 情感分析
  • 8. 感知机和逻辑回归

1. 自然语言处理介绍

  • 自然语言处理的目标是什么
    1. 能够解决需要深入理解(deep understanding)文本的问题。
    2. 能够构建与我们交流的系统:对话系统(dialogue system)、机器翻译(machine translation)、摘要(summarization)等。
    3. 能够构建从文本中抽取信息(extract information)并回答问题(answer question)的系统。

在这里插入图片描述

在这里插入图片描述

  • 标准自然语言处理流程(pipeline)
    1. 获取原始文本(text)。
    2. 进行文本分析(text analysis):包括句法/语法分析(syntactic parse),共指/指代消解(coreference resolution),实体消歧(entity disambiguation),话语/篇章分析(discourse analysis)等。
    3. 对文本进行标注(annotation)。
    4. 实际应用(application):摘要/总结(summarize),抽取信息(extract information),回答问题(answer question),识别情绪(identify sentiment),翻译(translate)等等。

流程中涉及到的所有组件都是使用机器学习的统计方法建模的。

在这里插入图片描述

2. 线性二分类

线性二分类(Linear Binary Classification)是一种机器学习中的分类算法,用于将输入数据分为两个互斥的类别。它基于线性模型的概念,尝试在特征空间中找到一个线性边界,将属于不同类别的数据点分开。

在线性二分类中,每个数据点通过一组特征表示,例如向量。算法的目标是找到一个超平面(在二维空间中即为一条直线),它可以最好地将属于不同类别的数据点分开。这个超平面可以被视为一个决策边界,根据数据点在超平面的哪一侧,将其划分为不同的类别。

为了实现线性二分类,常用的算法包括逻辑回归(Logistic Regression)和支持向量机(Support Vector Machines)等。这些算法通过学习适当的权重和偏差参数,来定义决策边界的位置和方向。

  • 线性二分类算法

给定文本 x ˉ \bar{x} xˉ,通过特征提取器(feature extractor) f f f 转为数值向量,

x ˉ : string → f ( x ˉ ) ∈ R d \bar{x}: \text{string} \rightarrow f(\bar{x}) \in \mathbb{R}^d xˉ:stringf(xˉ)Rd

然后输入给带有权重(weight)和偏置(bias)的分类器(classifier),得到分类超平面(决策边界,decision boundary),超平面两边分属两个类别。

w ˉ T f ( x ˉ ) ≥ 0 \bar{w}^T f(\bar{x}) \geq 0 wˉTf(xˉ)0

在这里插入图片描述

3. 情感分析和基础特征提取

3.1. 情感分析

情感分析(Sentiment Analysis)是一种文本分析技术,用于确定给定文本中的情感倾向或情感极性。它可以帮助我们了解文本中的情感状态,例如正面、负面或中性。情感分析在许多领域都有广泛的应用,包括社交媒体分析、产品评论、舆情监测等。

情感分析 vs 情绪分析

情感分析(Sentiment Analysis)和情绪分析(Emotional Analysis)是两种在文本分析中用于理解情感和情绪的方法,但它们有一些区别。

情感分析(Sentiment Analysis)关注的是文本中的情感倾向或情感极性。它旨在确定文本是积极的、消极的还是中性的。情感分析通常使用情感词典、机器学习算法或深度学习模型来对文本进行情感分类。它可以用于分析产品评论、社交媒体帖子、新闻文章等,以了解公众对某个主题或产品的情感反应。

情绪分析(Emotional Analysis)则更加关注文本中的情绪状态。它试图识别文本中表达的具体情绪,如喜悦、愤怒、悲伤、恐惧等。情绪分析通常涉及对情绪词汇、情绪模型或语义规则的分析,以确定文本所包含的情绪类型。情绪分析可用于社交媒体数据、用户评论、电影评论等领域,以了解人们在特定情境下的情绪体验。

情感分析更关注整体情感倾向,而情绪分析更关注具体的情绪类型和情感状态。

  • 情感分析任务示例

这个电影好,想再看这个电影。 【积极的、好评】

这个电影不好,不想再看这个电影了。【消极的、差评】

3.2. 特征提取

特征提取(Feature Extraction)指的是从文本数据中提取有用信息的过程。它涉及对文本进行预处理和转换,以便能够捕捉文本的关键特征。一些常见的基本特征包括词频(某个词在文本中出现的次数)、词袋模型(文本中所有词的集合)、文本长度等。通过提取这些基本特征,我们可以更好地理解文本数据并进行进一步的分析和建模。

x ˉ : string → f ( x ˉ ) ∈ R d \bar{x}: \text{string} \rightarrow f(\bar{x}) \in \mathbb{R}^d xˉ:stringf(xˉ)Rd

  • 训练数据集

带有标签的数据进行特征抽取后作为标注数据集
{ f ( x ˉ ( i ) ) , y ( i ) } i = 1 D \{ f(\bar{x}^{(i)}), y^{(i)} \}_{i=1}^D {f(xˉ(i)),y(i)}i=1D
可以直接训练分类器。

  • 特征提取 - 词袋模型

词袋模型(Bag-of-Words Model)是一种常用的文本表示方法。它将文本视为一个袋子(或集合)中的词汇的无序集合,忽略了词汇的语法和顺序,仅关注词汇的出现频率。

词袋模型的基本思想是将文本转换为一个向量,其中向量的每个维度对应于词汇表中的一个单词。每个维度的值表示该单词在文本中出现的次数或其他权重值(如TF-IDF)。通过这种方式,我们可以将文本表示为数值化的特征向量,以便在机器学习模型中进一步处理和分析。

下面是一个简单的示例来说明词袋模型的概念。假设我们有以下两个句子:

句子一:这个电影好,想再看这个电影。

句子二:这个电影不好,不想再看这个电影了。

使用词袋模型,我们可以构建词汇表如下:

[‘这个’, ‘电影’, ‘好’, ‘,’, ‘想’, ‘再’, ‘看’, ‘。’, ‘不好’, ‘不想’, ‘了’]

然后,我们可以计算每个句子在词汇表中的词频,得到对应的特征向量:

句子一的特征向量:[2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0]

句子二的特征向量:[2, 2, 0, 1, 0, 1, 1, 1, 1, 1, 1]

通过这种方式,我们将文本表示为了数值化的特征向量,其中每个维度表示了对应词汇在文本中出现的次数。词袋模型简化了文本的复杂性,使得文本可以更方便地被计算机处理和分析。然而,它忽略了词汇的顺序和上下文信息,可能会丢失一些语义和语境相关的信息。

import jiebasentence1 = "这个电影好,想再看这个电影。"
sentence2 = "这个电影不好,不想再看这个电影了。"sentence1_tokenized = jieba.lcut(sentence1)
sentence2_tokenized = jieba.lcut(sentence2)
print("句子一分词结果:", sentence1_tokenized)
print("句子二分词结果:", sentence2_tokenized)vocabulary = []
for word in sentence1_tokenized + sentence2_tokenized:if word not in vocabulary:vocabulary.append(word)
print("词表:", vocabulary)sentence1_feature = [0] * len(vocabulary)
for word in sentence1_tokenized:index = vocabulary.index(word)sentence1_feature[index] += 1
print("句子一的特征向量(bow):", sentence1_feature)sentence2_feature = [0] * len(vocabulary)
for word in sentence2_tokenized:index = vocabulary.index(word)sentence2_feature[index] += 1
print("句子一的特征向量(bow):", sentence2_feature)
  • 特征提取 - N 元语法模型

N 元语法(N-gram)是一种常用的文本表示方法,而 Bag of Ngrams 则是基于 N 元语法和词袋模型的一种扩展模型。N 元语法表示文本中连续 N 个词的组合,例如二元语法(2-gram)表示连续两个词的组合,三元语法(3-gram)表示连续三个词的组合,以此类推。N 元语法可以捕捉到一定的上下文信息,并且在一些文本任务中具有一定的效果。Bag of Ngrams 模型扩展了词袋模型(Bag-of-Words Model),将 N 元语法作为特征进行文本表示。

下面是一个简单的示例来说明 Bag of Ngrams 模型的概念。假设我们有以下两个句子:

句子一:这个电影好,想再看这个电影。

句子二:这个电影不好,不想再看这个电影了。

使用 Bag of Ngrams 模型,我们可以构建 2-gram 词汇表如下:

[‘这个电影’, ‘电影好’, ‘好,’, ‘,想’, ‘想再’, ‘再看’, ‘看这个’, ‘电影。’, ‘。这个’, ‘电影不好’, ‘不好,’, ‘,不想’, ‘不想再’, ‘电影了’, ‘了。’]

然后,我们可以计算每个 2-gram 在句子中出现的次数,得到对应的特征向量:

句子一的特征向量:[2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]

句子二的特征向量:[2, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1]

通过这种方式,我们将每个句子表示为一个向量,其中向量的每个位置表示对应2-gram在句子中出现的次数。从特征向量可以看出 2-gram 比词袋模型更有区分性。

import jiebasentence1 = "这个电影好,想再看这个电影。"
sentence2 = "这个电影不好,不想再看这个电影了。"sentence1_tokenized = jieba.lcut(sentence1)
sentence2_tokenized = jieba.lcut(sentence2)
print("句子一分词结果:", sentence1_tokenized)
print("句子二分词结果:", sentence2_tokenized)vocabulary = []
tokenized = sentence1_tokenized + sentence2_tokenized
for two_gram in zip(tokenized, tokenized[1:]):two_gram_str = "".join(two_gram)if two_gram_str not in vocabulary:vocabulary.append(two_gram_str)
print("N-gram 词表:", vocabulary)sentence1_feature = [0] * len(vocabulary)
for i in range(len(sentence1_tokenized) - 1):two_gram_str = "".join(sentence1_tokenized[i:i + 2])index = vocabulary.index(two_gram_str)sentence1_feature[index] += 1
print("句子一的特征向量(2-gram):", sentence1_feature)sentence2_feature = [0] * len(vocabulary)
for i in range(len(sentence2_tokenized) - 1):two_gram_str = "".join(sentence2_tokenized[i:i + 2])index = vocabulary.index(two_gram_str)sentence2_feature[index] += 1
print("句子二的特征向量(2-gram):", sentence2_feature)

词袋模型 vs Bag of Ngrams 模型

Bag of Ngrams 模型相对于词袋模型具有考虑词序和局部上下文的优势,适用于一些需要捕捉词序和上下文关系的任务。然而,根据具体任务和数据集的特点,选择合适的文本表示方法是很重要的,有时词袋模型可能更适用。

  • 词频逆文档频率(TF-IDF)

词频逆文档频率(Term Frequency-Inverse Document Frequency,TF-IDF)是一种常用的特征权重计算方法,用于衡量一个词在文档中的重要性。它结合了词频(term frequency)和逆文档频率(inverse document frequency)两个因素。Bag of Ngrams 模型和词袋模型都仅仅使用了词频或 N-gram 频率。

Bag of Ngrams 模型和词袋模型都可以与 TF-IDF 一起使用。在词袋模型中,每个文档可以表示为一个向量,其中每个维度对应一个词,并记录该词在文档中的出现次数。使用 TF-IDF,可以将词袋模型中的词频进行加权,使得更重要的词获得更高的权重。在 Bag of Ngrams 模型中,每个文档也可以表示为一个向量,其中每个维度对应一个 N-gram,并记录该 N-gram 在文档中的出现次数。同样地,可以使用 TF-IDF 来对 N-grams 进行加权,以考虑它们在整个语料库中的重要性。

通过使用 TF-IDF,可以降低常见词(如“the”、“is”等)的权重,提高具有更高信息量的词或 N-grams 的权重。这有助于突出文本中的关键信息,对于一些文本处理任务,如文本分类、信息检索和文本聚类等,可以提升性能。因此,Bag of Ngrams 模型和词袋模型与 TF-IDF 相结合,可以更好地表示文本并捕捉关键信息。

TF-IDF 是通过以下步骤计算的:

计算词频(Term Frequency,TF):对于给定的文档,计算每个词在文档中的出现频率。可以使用简单计数或标准化的词频计算方法,如将词频除以文档中的总词数,以避免较长文档对词频的影响。

词频(TF)= 词在文档中的出现次数 / 文档中的总词数
计算逆文档频率(Inverse Document Frequency,IDF):计算每个词的逆文档频率,表示该词在整个文档集合中的重要性。逆文档频率可以通过以下公式计算:

IDF = log(总文档数 / 包含该词的文档数)

其中,总文档数是语料库中的文档总数,包含该词的文档数是包含该词的文档的数量。
计算 TF-IDF 权重:将词频(TF)和逆文档频率(IDF)相乘,得到最终的 TF-IDF 权重。

TF-IDF = TF * IDF

通过计算 TF-IDF 权重,可以衡量一个词在单个文档中的重要性(通过 TF),以及在整个文档集合中的稀有程度(通过 IDF)。常见词在多个文档中频繁出现,其 TF 较高但 IDF 较低,因此其权重会相对较低。而对于在少数文档中出现但具有较高信息量的词,其 TF 较高且 IDF 较高,因此其权重会相对较高。需要注意的是,TF-IDF 权重的计算可以在整个文档集合上进行,也可以在单个文档内部进行。

3.3. 文本预处理

  • 中文分词(Word Segmentation)和英文分词(Tokenization)

中文分词是将连续的中文字符序列切分成有意义的词语。中文中没有像空格那样明显的词语分隔符,因此需要使用中文分词工具,如jieba、hanlp等。

英文分词将连续的英文文本切分为单词或标点符号。英文文本中通常以空格作为词语的分隔符,但仍需处理标点符号等特殊情况。常用的分词工具有 NLTK、SpaCy 等。

  • 停用词过滤(Stop Word Filtering)

中文和英文都需要过滤停用词,去除一些常见且对文本分析任务贡献较少的停用词,例如“的”,“是”,“在”,“the”,“is”,“in”等。可以使用预定义的停用词列表或基于统计方法自动选择停用词。停用词列表可根据任务和语料库进行定制。

  • 文本规范化(Text Normalization)

对于中文来说,文本规范化需要处理中文文本中的繁体字、拼音、缩写、汉字表示的数字等,将其转换为标准化的形式。这有助于提高文本的一致性和可处理性。

对于英文来说,文本规范化需要进行大小写转换(Lowercasing/Uppercasing)以避免同一个单词因大小写不同而被视为不同的词。词形还原(Lemmatization)和词干提取(stemming)将单词还原为其原始或基本形式,以减少词形的变化对文本处理的影响。

词形还原是将单词还原为其在词典中的原始形式(称为词元或词根),以保留单词的语义信息。词形还原考虑了词性和上下文,以确保还原后的单词是有效的词元。例如:单词 “running”,词形还原结果 “run”。单词 “better”,词形还原结果 “good”。单词 “went”,词形还原结果:“go”。在这些示例中,词形还原将单词还原为其原始形式,去除了时态、派生后缀等,使得不同形式的单词都归并到相同的基本形式上。

词干提取是一种简化的单词还原方法,通过删除单词的后缀来获得词干(即词的基本形式),而不考虑词性和上下文。词干提取可能会生成一些非词元的形式,但它具有较高的运行效率。例如:单词 “running”,词干提取结果 “run”。单词 “better”,词干提取结果"better"。单词 “went”,词干提取结果 “went”。在这些示例中,词干提取通过去除后缀,将单词简化为其词干形式。词干提取不考虑词性和语义,因此可能会产生一些不是真正的单词,但它在某些情况下可以作为一种简化文本处理的方法。

需要注意的是,词形还原通常比词干提取更复杂,并且在某些任务中更为准确。选择使用词形还原还是词干提取取决于具体的应用场景和任务要求。

  • 文本预处理的优点

这些预处理步骤有助于减少噪音、统一文本表示,提取有用的信息,为后续的文本分析任务奠定基础。具体的预处理步骤和顺序可能因不同任务和数据而有所变化。

  • 文本预处理 Python 实现
import jieba
import nltk
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
from nltk.stem import PorterStemmernltk.download('punkt')# 中文分词和停用词过滤
stopwords = ['的', '了', '和', '是', '就', '都', '而', '及', '与', '或', '个', '也', '这']
text = "我喜欢看电影,尤其喜欢科幻电影和动作片。"
tokenized_list = jieba.lcut(text)
print("中文分词结果:", tokenized_list)tokenized_remove_stopword_list = [word for word in tokenized_list if word not in stopwords]
print("中文停用词过滤后的分词结果:", tokenized_remove_stopword_list)# 英文分词和词形还原
text = "cats ate running better"
words = word_tokenize(text)
print("英文分词结果:", words)lemmatizer = WordNetLemmatizer()  # 词形还原器
lemmatized_words = [lemmatizer.lemmatize(word) for word in words]
print("词形还原结果:", lemmatized_words)stemmer = PorterStemmer()         # 词干提取器
stemmed_words = [stemmer.stem(word) for word in words]
print("词干提取结果:", stemmed_words)

4. 学习的基础 - 梯度下降算法

梯度下降算法(Gradient Descent)是一种常用的优化算法,用于找到函数的最小值或最大值(梯度上升)。它通过迭代更新参数的方式来逐步逼近最优解。

  • 算法流程

假设有一个可微的函数 f ( x ) f(x) f(x)(机器学习中的目标函数),我们的目标是找到使得 f ( x ) f(x) f(x) 达到最小值的 x x x 值。梯度下降算法通过迭代更新参数的方式来逐步逼近最小值。

  1. 初始化参数 x x x 和学习率 α \alpha α
  2. 计算函数 f ( x ) f(x) f(x) 的梯度,即 f ′ ( x ) f^{\prime}(x) f(x)
  3. 更新参数 x : = x − α ∗ f ′ ( x ) x := x - \alpha * f^{\prime}(x) x:=xαf(x)
  4. 重复步骤 2 和步骤 3,直到满足停止条件(例如达到最大迭代次数或梯度变化很小)。

这样,通过不断更新参数 x x x,梯度下降算法可以逐步接近最小值点。

以一维坐标为例,梯度主要表示的是变化率,梯度的值可以告诉我们函数在该点上是增长还是减小,以及增长或减小的速度有多快。

学习率是一个超参数,用于控制参数更新的步长或称为学习步长。学习率决定了我们在每次参数更新中沿着梯度方向移动的距离。较大的学习率意味着我们会更快地接近最小值,但可能会导致参数在最小值附近波动或无法收敛。较小的学习率意味着我们会以较小的步长更新参数,可能需要更多的迭代次数才能收敛到最小值。

梯度和学习率共同作用的方式是通过乘积来确定参数的更新量。学习率乘以梯度确定了参数更新的步长。较大的学习率会导致更大的步长,而较小的学习率会导致更小的步长。因此,学习率可以控制参数更新的速度和稳定性。选择合适的学习率是梯度下降算法中的一个关键问题。如果学习率过大,可能会导致参数在最小值附近来回震荡甚至发散;如果学习率过小,可能会导致收敛速度过慢或陷入局部最小值。

  • 为什么梯度的负方向就是损失下降最快的方向

梯度下降算法中选择梯度的负方向作为更新方向的理论依据主要来自于微积分中的一阶导数和泰勒展开的思想。

根据微积分中的一阶导数的定义,函数在某一点的导数表示了函数在该点的变化率和变化的方向。对于多变量函数,梯度可以看作是导数的推广,表示了函数在每个参数维度上的变化率和变化的方向。

梯度的方向指示了函数在当前点的最大上升率,而负梯度的方向则指示了函数在当前点的最大下降率。因此,负梯度的方向可以被认为是函数下降最快的方向。

在一个点上,借助于泰特展开,我们有

f ( x + δ ) − f ( x ) ≈ f ′ ( x ) ⋅ δ f(x + \delta) - f(x) \approx f^{\prime}(x) \cdot \delta f(x+δ)f(x)f(x)δ

其中, f ′ ( x ) f^{\prime}(x) f(x) δ \delta δ 为向量,那么这两者的内积就等于

f ′ ( x ) ⋅ δ = ∣ ∣ f ′ ( x ) ∣ ∣ ⋅ ∣ ∣ δ ∣ ∣ ⋅ cos ⁡ θ f^{\prime}(x) \cdot \delta = ||f^{\prime}(x)|| \cdot ||\delta|| \cdot \cos \theta f(x)δ=∣∣f(x)∣∣∣∣δ∣∣cosθ

θ = π \theta = \pi θ=π 时,也就是 θ \theta θ f ′ ( x ) f^{\prime}(x) f(x) 的负方向上时,取得最小值,也就是下降的最快的方向了

f ( x ) = x 2 + 5 ∗ sin ⁡ ( x ) f(x) = x^2 + 5*\sin(x) f(x)=x2+5sin(x) 为例,求解步骤如下:

import numpy as np
import matplotlib.pyplot as plt# 定义函数 f(x)
def f(x):return x ** 2 + 5 * np.sin(x)# 定义函数 f(x) 的导数
def f_derivative(x):return 2 * x + 5 * np.cos(x)# 梯度下降算法
def gradient_descent(x_start, learning_rate, num_iterations):x = x_starthistory = [x]                      # 保存每次迭代后的 x 值for _ in range(num_iterations):gradient = f_derivative(x)     # 计算梯度x -= learning_rate * gradient  # 更新参数 xhistory.append(x)              # 保存更新后的 x 值return x, history# 设置初始参数和学习率
x_start = -3         # 初始参数值
learning_rate = 0.1  # 学习率
num_iterations = 50  # 迭代次数# 运行梯度下降算法
x_min, x_history = gradient_descent(x_start, learning_rate, num_iterations)# 输出最小值和最小值对应的 x 值
print("最小值:", f(x_min))
print("最小值对应的 x 值:", x_min)# 绘制函数曲线和梯度下降过程
x = np.linspace(-5, 5, 100)
y = f(x)
plt.plot(x, y, label='f(x)')
plt.scatter(x_history, f(np.array(x_history)), c='r', label='Gradient Descent Point')
plt.legend()
plt.xlabel('x')
plt.ylabel('f(x)')
plt.show()

运行上述代码,将得到函数 f ( x ) f(x) f(x) 的最小值和最小值对应的 x x x 值,并绘制出函数曲线和梯度下降过程的图形。

在这里插入图片描述

5. 感知机

感知机(Perceptron)是一种简单的二分类线性分类模型,由美国科学家 Frank Rosenblatt 在1957年提出。它是人工神经网络的基础,也是神经网络发展的起点之一。

感知机模型由输入层、权重、激活函数和输出层组成。它的输入是一组特征向量,每个特征都有一个对应的权重。感知机通过将输入特征与对应的权重相乘并加权求和,然后通过激活函数进行非线性变换,得到最终的输出结果。

具体而言,对于一个输入特征向量 x = ( x 1 , x 2 , . . . , x n ) x = (x_1, x_2, ..., x_n) x=(x1,x2,...,xn),感知机模型的输出 y y y 是通过以下步骤计算得到的:

  1. 对于每个输入特征 x i x_i xi,与对应的权重 w i w_i wi 相乘并求和,得到加权求和结果 z = w 1 x 1 + w 2 x 2 + . . . + w n x n z = w_1 x_1 + w_2 x_2 + ... + w_n x_n z=w1x1+w2x2+...+wnxn

  2. 将加权求和结果 z z z 输入到激活函数(通常为阶跃函数或符号函数)中,根据激活函数的输出确定感知机的最终输出 y y y。例如,对于阶跃函数,如果 z z z 大于等于某个阈值(通常为0),则输出为正类(1),否则输出为负类(-1)。

感知机模型的训练过程旨在调整权重值,使得模型能够正确地对输入样本进行分类。训练过程使用随机梯度下降算法,通过迭代调整权重,使得模型的分类结果与真实标签一致。需要注意的是,感知机模型只能处理线性可分的情况,即存在一个超平面可以将不同类别的样本完全分开。对于线性不可分的问题,感知机无法收敛到一个满足要求的解。为了处理线性不可分问题,后续发展出了更复杂的分类模型,如多层感知机(Multilayer Perceptron)。

感知机使用的是随机梯度下降(Stochastic Gradient Descent,SGD)算法与传统的梯度下降算法不同,感知机的损失函数不是可微的,因此无法直接使用梯度下降算法。相反,感知机使用了一个简化的更新规则来进行参数更新。梯度下降算法的一般形式是基于损失函数的梯度进行参数更新。但感知机使用的是误分类点的梯度,即每次只选择一个误分类点进行参数更新。

下面是感知机的梯度下降更新规则的简化形式:

  1. 对于一个误分类的样本 ( x , y ) (x, y) (x,y),其中 x x x 是输入特征向量, y y y 是真实标签。预测结果为 y _ p r e d y\_pred y_pred
  2. 根据预测结果 y _ p r e d y\_pred y_pred 和真实标签 y y y 的差异来计算更新量 δ = α ∗ ( y − y _ p r e d ) \delta = \alpha * (y - y\_pred) δ=α(yy_pred)
  3. 更新权重和偏置: w _ n e w = w _ o l d + δ ∗ x w\_new = w\_old + \delta * x w_new=w_old+δx b _ n e w = b _ o l d + δ b\_new = b\_old + \delta b_new=b_old+δ。在更新权重的过程中 x x x 是输入样本的特征信息,如果没有 x x x 而只有一个更新量 update。这样的更新方式将无法正确地调整权重,使感知机模型能够更好地适应输入数据。没有输入特征信息,将无法正确地调整权重,导致模型不能准确地对样本进行分类。

需要注意的是,感知机只针对误分类点进行参数更新,因此这种更新方式可以将误分类点推向正确的一侧,直到所有样本被正确分类或达到指定的迭代次数。这是感知机使用的简化梯度下降更新规则,与传统梯度下降算法有所不同。传统梯度下降算法通常涉及对整个训练集的梯度计算和参数更新,而感知机仅处理误分类点。

  • 感知机 Python 实现

在这里插入图片描述

下面用 Python 实现感知机用于对第一象限和第三象限的点进行分类:

import numpy as npclass Perceptron:def __init__(self, input_size):self.weights = np.zeros(input_size)self.bias = 0def predict(self, inputs):activation = np.dot(inputs, self.weights) + self.biasreturn np.where(activation >= 0, 1, -1)def train(self, inputs, labels, learning_rate, epochs):for _ in range(epochs):for i in range(len(inputs)):prediction = self.predict(inputs[i])if prediction != labels[i]:update = learning_rate * (labels[i] - prediction)self.weights += update * inputs[i]self.bias += update# 训练数据
inputs = np.array([[2, 1], [3, 4], [-2, -1], [-3, -2]])
labels = np.array([1, 1, -1, -1])# 创建感知机对象
perceptron = Perceptron(input_size=2)# 训练感知机
perceptron.train(inputs, labels, learning_rate=0.1, epochs=10)# 测试感知机
test_inputs = np.array([[400, 194], [-13, -34]])
predictions = perceptron.predict(test_inputs)# 输出预测结果
for i in range(len(test_inputs)):print(f"Input: {test_inputs[i]}, Prediction: {predictions[i]}")

6. 逻辑回归

逻辑回归(Logistic Regression)是一种用于二分类问题的统计学习方法,逻辑回归是一种判别式概率模型。具体来说,逻辑回归使用线性回归模型的输出(线性组合)作为输入,然后通过 logistic 函数将其转换为一个在0到1之间的概率值。这个概率值表示样本属于某个特定类别的概率。基于这个概率值,我们可以进行分类决策,将概率大于一个阈值的样本划分为正类,概率小于阈值的样本划分为负类。

逻辑回归之所以被称为"回归",是因为它的数学基础和一般的线性回归方法有一些相似之处。逻辑回归的名称起源于它的数学形式和推导过程。在逻辑回归中,主要是使用线性回归方法来建立模型,然后利用 logistic 函数(也称为 sigmoid 函数)将线性模型的输出映射到概率,即目标是预测样本的类别而不是连续的数值结果。

判别式概率模型(Discriminative Probabilistic Model)和生成式概率模型(Generative Probabilistic Model)是两种常见的概率建模方法,它们的区别如下:

目标:

  • 判别式概率模型的目标是建立一个条件概率分布 P(y|x),即给定输入 x,预测输出 y 的条件概率。它主要关注于学习输入和输出之间的直接关系,用于分类和回归等判别任务。
  • 生成式概率模型的目标是建立联合概率分布 P(x, y),即同时建模输入 x 和输出 y 的联合概率分布。它不仅关注输入和输出之间的关系,还可以生成新样本,用于生成、聚类等任务。

建模方法:

  • 判别式概率模型通过学习条件概率 P(y|x) 来直接建模输入和输出之间的关系。常见的判别式模型包括逻辑回归、支持向量机(SVM)、神经网络等。
  • 生成式概率模型通过学习联合概率分布 P(x, y) 来建模输入和输出之间的关系。常见的生成式模型包括朴素贝叶斯、高斯混合模型(GMM)、隐马尔可夫模型(HMM)等。

数据生成:

  • 判别式概率模型主要关注预测输出 y,通常不直接生成新的输入样本。它通过学习训练数据中的模式来进行分类或回归预测。
  • 生成式概率模型可以通过联合概率分布 P(x, y) 来生成新的输入样本。它可以模拟数据的分布,生成符合该分布的新样本。
  • 逻辑回归算法的基本流程:
  1. 数据预处理:首先,需要对输入数据进行预处理,包括特征缩放、处理缺失值、处理异常值等。还可以进行特征选择或转换,以提高模型性能。
  2. 定义模型:逻辑回归使用 logistic 函数(也称为 sigmoid 函数)将线性模型的输出映射到概率值。定义模型和决策边界(decision boundary)如下

z = w ˉ T f ( x ˉ ) y ^ = P ( y ∣ x ˉ ) = 1 1 + e − z y = { + 1 , if  P ( y ∣ x ˉ ) > threshold − 1 , if other \begin{aligned} z &= \bar{w}^T f(\bar{x}) \\ \hat{y} &= P(y|\bar{x}) = \frac{1}{1 + e^{-z}} \\ y &= \begin{cases} +1, \quad \text{if } P(y|\bar{x}) > \text{threshold} \\ -1, \quad \text{if } \text{other} \end{cases} \end{aligned} zy^y=wˉTf(xˉ)=P(yxˉ)=1+ez1={+1,if P(yxˉ)>threshold1,if other

在这里插入图片描述

  1. 损失函数:逻辑回归使用对数似然损失函数(log-likelihood loss)来衡量模型预测与真实标签之间的差异。

如果逻辑回归和线性回归一样,利用误差平方和来当作损失函数。对于给定的训练集,损失函数如下:

L ( y , y ^ ) = 1 2 ∑ i ( y i − y ^ i ) 2 \mathcal{L}(y, \hat{y}) = \frac{1}{2} \sum_i (y^i - \hat{y}^i)^2 L(y,y^)=21i(yiy^i)2

y i y^i yi 表示第 i i i 个样本的真实值, y ^ i \hat{y}^i y^i 表示第 i i i 个样本的预测值。如果把 y ^ i \hat{y}^i y^i 带入损失函数公式中,会发现这是一个非凸函数,这就意味着损失函数有着许多的局部最小值,这不利于我们的求解。

在这里插入图片描述

逻辑回归使用的常见损失函数是二元交叉熵损失函数(Binary Cross-Entropy Loss)。逻辑回归假设数据服从伯努利分布,假设模型的输出值是样本为正例的概率。因此有

P ( y = 1 ∣ x ) = y ^ P ( y = 0 ∣ x ) = 1 − y ^ \begin{aligned} P(y=1|x) &= \hat{y} \\ P(y=0|x) &= 1 - \hat{y} \\ \end{aligned} P(y=1∣x)P(y=0∣x)=y^=1y^

上面两式可以写成一般形式

P ( y ∣ x ) = y ^ y ( 1 − y ^ ) ( 1 − y ) P(y|x) = \hat{y}^y (1 - \hat{y})^{(1-y)} P(yx)=y^y(1y^)(1y)

接下来我们就要用极大似然估计(maximum likelihood estimation)来根据给定的训练集估计出参数

L ( w ) = ∏ i = 1 n P ( y i ∣ x i ; w ) = ∏ i = 1 n ( y ^ i ) y i ( 1 − y ^ i ) ( 1 − y i ) L(w) = \prod_{i=1}^n P(y^i|x^i;w) = \prod_{i=1}^n (\hat{y}^i)^{y^i} (1 - \hat{y}^i)^{(1-y^i)} L(w)=i=1nP(yixi;w)=i=1n(y^i)yi(1y^i)(1yi)

为了简化运算,我们对上面这个等式的两边都取一个对数

log ⁡ L ( w ) = ∑ i = 1 n ( y i log ⁡ y ^ i + ( 1 − y i ) log ⁡ ( 1 − y ^ i ) ) \log L(w) = \sum_{i=1}^n (y^i \log \hat{y}^i + (1-y^i) \log (1 - \hat{y}^i)) logL(w)=i=1n(yilogy^i+(1yi)log(1y^i))

以上是求是的 L ( w ) L(w) L(w) 最大的参数 w w w,加个负号就成了求最小的损失函数了,即最小化负对数似然(negative log likelihood,NLL)。

L = − log ⁡ L ( w ) = − ∑ i = 1 n ( y i log ⁡ y ^ i + ( 1 − y i ) log ⁡ ( 1 − y ^ i ) ) \mathcal{L} = -\log L(w) = -\sum_{i=1}^n (y^i \log \hat{y}^i + (1-y^i) \log (1 - \hat{y}^i)) L=logL(w)=i=1n(yilogy^i+(1yi)log(1y^i))

$$
\mathcal{L} =
\begin{cases}

  • \log \hat{y} &\text{if } y=1 \
  • \log (1 - \hat{y}) &\text{if } y=0
    \end{cases}
    $$

在这里插入图片描述

该损失函数的直观解释是,当真实标签 y y y 为1时,希望预测概率 y ^ \hat{y} y^ 越接近1越好;而当真实标签 y y y 为0时,希望预测概率 y ^ \hat{y} y^ 越接近0越好。对于误分类的情况,损失函数会惩罚模型的预测偏离真实标签的程度。换句话说,如果样本的值是 1 的话,估计值越接近 1 付出的代价就越小,反之越大;同理,如果样本的值是 0 的话,估计值越接近 0 付出的代价就越小,反之越大。因此,损失函数也称为成本函数或代价函数或目标函数。

  1. 参数优化:使用梯度下降(Gradient Descent)等优化算法,最小化损失函数来更新模型参数。

w : = w + Δ w = w − η Δ L ( w ) w j : = w j + Δ w j = w j − η L ( w ) w j \begin{aligned} w &:= w + \Delta w = w - \eta \Delta \mathcal{L}(w) \\ w_j &:= w_j + \Delta w_j = w_j - \eta \frac{\mathcal{L}(w)}{w_j} \\ \end{aligned} wwj:=w+Δw=wηΔL(w):=wj+Δwj=wjηwjL(w)

其中, w j w_j wj 表示第 j j j 个特征的权重, η \eta η 为学习率用来控制步长。

L ( w ) w j = − ∑ i = 1 n ( y i 1 y ^ i + ( 1 − y i ) 1 ( 1 − y ^ i ) ) ∂ y ^ i ∂ w j = − ∑ i = 1 n ( y i 1 y ^ i + ( 1 − y i ) 1 ( 1 − y ^ i ) ) y ^ i ( 1 − y ^ i ) ∂ z ^ i ∂ w j = − ∑ i = 1 n ( y i ( 1 − y ^ i ) − ( 1 − y i ) y ^ i ) x j i = − ∑ i = 1 n ( y i − y ^ i ) x j i \begin{aligned} \frac{\mathcal{L}(w)}{w_j} &= -\sum_{i=1}^n (y^i \frac{1}{\hat{y}^i} + (1-y^i) \frac{1}{(1 - \hat{y}^i)}) \frac{\partial \hat{y}^i}{\partial w_j} \\ &= -\sum_{i=1}^n (y^i \frac{1}{\hat{y}^i} + (1-y^i) \frac{1}{(1 - \hat{y}^i)}) \hat{y}^i (1 - \hat{y}^i) \frac{\partial \hat{z}^i}{\partial w_j} \\ &= -\sum_{i=1}^n (y^i (1 - \hat{y}^i) - (1-y^i) \hat{y}^i) x^i_j \\ &= -\sum_{i=1}^n (y^i - \hat{y}^i) x^i_j \\ \end{aligned} wjL(w)=i=1n(yiy^i1+(1yi)(1y^i)1)wjy^i=i=1n(yiy^i1+(1yi)(1y^i)1)y^i(1y^i)wjz^i=i=1n(yi(1y^i)(1yi)y^i)xji=i=1n(yiy^i)xji

在使用梯度下降法更新权重时,只要根据下式即可

w j : = w j + η ∑ i = 1 n ( y i − y ^ i ) x j i \begin{aligned} w_j := w_j + \eta \sum_{i=1}^n (y^i - \hat{y}^i) x^i_j \end{aligned} wj:=wj+ηi=1n(yiy^i)xji

  • Python 实现逻辑回归的梯度下降算法
import numpy as np
import matplotlib.pyplot as pltdef sigmoid(z):return 1 / (1 + np.exp(-z))def compute_loss(X, y, theta):y_pred = sigmoid(np.dot(X, theta))epsilon = 1e-5  # 用于避免log(0)的情况loss = -np.mean(y * np.log(y_pred + epsilon) + (1 - y) * np.log(1 - y_pred + epsilon))return lossdef gradient_descent(X, y, learning_rate, num_iterations):num_samples, num_features = X.shapetheta = np.zeros((num_features, 1))loss_history = []for _ in range(num_iterations):y_pred = sigmoid(np.dot(X, theta))loss = compute_loss(X, y, theta)gradient = (1/num_samples) * np.dot(X.T, (y_pred - y))theta -= learning_rate * gradientloss_history.append(loss)return theta, loss_historynp.random.seed(0)
num_samples = 100
X_positive = np.random.normal(loc=2, scale=1, size=(num_samples, 2))
X_negative = np.random.normal(loc=-2, scale=1, size=(num_samples, 2))
X = np.vstack((X_positive, X_negative))
y = np.vstack((np.ones((num_samples, 1)), np.zeros((num_samples, 1))))X = np.hstack((np.ones((2*num_samples, 1)), X))
X[:, 1:] = (X[:, 1:] - np.mean(X[:, 1:], axis=0)) / np.std(X[:, 1:], axis=0)learning_rate = 0.1
num_iterations = 1000
theta, loss_history = gradient_descent(X, y, learning_rate, num_iterations)plt.plot(loss_history)
plt.xlabel('Iterations')
plt.ylabel('Loss')
plt.title('Loss Convergence')
plt.show()# 生成测试样本
X_test = np.array([[1, 1, 1.5], [1, -1, -1.5]])
# 使用训练后的参数进行预测
y_pred = sigmoid(np.dot(X_test, theta))
print(y_pred)

损失的收敛情况如下:

在这里插入图片描述

7. 情感分析

斯坦福情绪树库(Stanford Sentiment Treebank,SST)数据集介绍

情感分析是对给定文本进行极性分类的任务。SST 是典型情感分析的任务,模型必须分析文本的情感。例如,判断餐厅评论是积极还是消极的形式。关于 SST 更多细节见上述链接。更多情感分析数据集见 Sentiment Analysis。

  1. The food at this restaurant is absolutely amazing! I highly recommend it to everyone.

  2. I had a terrible experience at this place. The service was terrible and the food was tasteless.

对完整句子进行二元分类(将中性句子排除,仅考虑负面或稍微负面 vs 稍微正面或正面),称为 SST-2 或 SST 二元数据集。

最新的排行榜见 Leaderboard - GLUE Benchmark。

  • 情感分析示例
  1. this movie was great! would watch again 【积极的】
  2. the movie was gross and overwrought, but I liked it 【积极的】
  3. this movie was not really very enjoyable 【消极的】

根据以上示例可以看出,词袋模型似乎不够用,涉及到话语结构(discourse structure)、否定等问题。不过有一些方法可以解决这个问题,否定词(如 “not”)经常会改变句子的情感极性。为了更好地捕捉句子中的否定含义,可以提取以 “not” 为前缀的二元特征。这样可以将 “not” 和其后面的单词或短语作为一个整体来考虑,以更准确地判断句子的情感极性。通过提取这些 “not X” 的二元特征,可以捕捉到否定词对句子情感的影响,从而提高情感分类的性能。使用词袋模型构建一些简单的特征集合也能使得情感分析任务做的比较好了。

以下是一些机器学习在情感分析任务上的研究:

  1. Thumbs up? Sentiment Classification using Machine Learning Techniques

  2. Baselines and Bigrams: Simple, Good Sentiment and Topic Classification

  3. Convolutional Neural Networks for Sentence Classification

  • 使用词袋模型和逻辑回归作为情感分析的基本框架,数据集使用 SST-2
from datasets import load_dataset
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.feature_extraction.text import CountVectorizer# 加载SST-2数据集
dataset = load_dataset("glue", "sst2")# 获取训练集和验证集
train_data = dataset["train"]
valid_data = dataset["validation"]# 初始化词袋模型
vectorizer = CountVectorizer()# 将训练集文本转换为词袋特征表示
train_features = vectorizer.fit_transform(train_data["sentence"])# 将验证集文本转换为词袋特征表示
valid_features = vectorizer.transform(valid_data["sentence"])# 获取训练集标签
train_labels = train_data["label"]# 初始化逻辑回归模型,并增加最大迭代次数
classifier = LogisticRegression(max_iter=1000)  # 增加最大迭代次数为1000# 训练情感分类模型
classifier.fit(train_features, train_labels)# 预测训练集和验证集标签
train_predictions = classifier.predict(train_features)
valid_predictions = classifier.predict(valid_features)# 计算训练集和验证集准确率
train_accuracy = accuracy_score(train_labels, train_predictions)
valid_accuracy = accuracy_score(valid_data["label"], valid_predictions)print("训练集准确率:", train_accuracy)
print("验证集准确率:", valid_accuracy)

以上实验使用基础的词袋模型和逻辑回归,获得如下结果:

训练集准确率: 0.9379352328913569
验证集准确率: 0.8188073394495413

在实践中,还需要进行更多的预处理、特征工程和模型调优来提高性能。

8. 感知机和逻辑回归

感知器(Perceptron)、逻辑回归(Logistic Regression)和支持向量机(Support Vector Machine,SVM)之间存在一些联系和关联。

感知器是一种基本的二元分类算法,它模仿了神经元的工作原理。它通过计算输入特征的加权和,并将结果传递给激活函数,以确定输出类别。感知器通常使用阶跃函数作为激活函数,当加权和超过阈值时输出为正类,否则为负类。感知器通过迭代的方式对权重进行调整,以逐渐减少分类错误。

逻辑回归是一种广泛应用于分类问题的统计学习方法。与感知器不同,逻辑回归使用了一种称为逻辑函数(或称为sigmoid函数)的激活函数,将线性组合的结果映射到0到1之间的概率范围。逻辑回归通过最大化似然函数或最小化交叉熵损失函数来学习模型参数,从而找到最佳的决策边界。

支持向量机是一种强大的监督学习算法,可应用于二元和多元分类问题,以及回归问题。SVM的目标是找到一个最优超平面,将不同类别的数据点最大程度地分开,同时最小化分类错误。SVM使用核函数将数据映射到高维特征空间,从而使非线性问题也能有效解决。

感知器和逻辑回归可以看作是最简单的线性分类器,逻辑回归可以被视为感知器的扩展,使用了更灵活的激活函数和更复杂的参数估计方法。逻辑回归可以看作是一个概率化的线性分类器,将线性组合的结果转化为概率输出。而感知器仅基于硬阈值进行分类。SVM 则是一种更复杂的分类方法,它可以处理非线性问题,通过使用核函数将数据映射到高维空间来实现更高维度的分类边界。总而言之,感知器和逻辑回归是线性分类器的基础,而 SVM 则是一种更具表现力和灵活性的分类器,可以处理更复杂的问题。

更多细节见 Connections between Perceptron and Logistic Regression (and SVM)

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/10852.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

(2024,KAN,MLP,可训练激活函数,样条函数,分层函数)Kolmogorov–Arnold 网络

KAN: Kolmogorov–Arnold Networks 公和众和号:EDPJ(进 Q 交流群:922230617 或加 VX:CV_EDPJ 进 V 交流群) 目录 0. 摘要 1. 简介 2. KAN 2.1 KA 表示定理 2.2 KAN 架构 2.3 KAN 的逼近能力和缩放定律 2.4 对于…

国产操作系统下使用dpkg命令管理软件包 _ 统信 _ 麒麟 _ 中科方德

往期好文:国产操作系统下Chrome的命令行使用 | 统信 | 麒麟 Hello,大家好啊!在Linux系统中,dpkg是Debian包管理系统的基础命令工具,它允许用户安装、卸载、查询和管理软件包。在国产操作系统如统信UOS和麒麟KOS、中科方…

字节码基础

基本概念 java中的字节码,英文bytecode。是java代码编译后的中间代码格式。JVM需要读取并解析字节码才能执行相应的任务。java字节码是JVM的指令集。JVM加载字节码格式的class文件。校验之后通过JIT编译器转换成本机机器代码执行。 java字节码简介 1、java byteco…

阿里云部署ChatGLM-6B及ptuning微调教程

一、模型部署 1.进入阿里云人工智能平台PAI。 2.申请免费试用。 3.打开交互式建模 PAI-DSW。 4.新建实例。 5.填写配置。 6.实例准备完成后点击打开。 7.打开实例后点击Teminal。 8.在Teminal中依次输入以下命令并执行。 apt-get update apt-get install git-lfs git lfs ins…

SQLite利用事务实现批量插入(提升效率)

在尝试过SQLite批量插入一百万条记录,执行时长高达20多分钟后,就在想一个问题,这样的性能是不可能被广泛应用的,更不可能出现在真实的生产环境中,那么对此应该如何优化一下呢? 首先分析一下批量插入的逻辑 …

蓝桥杯-地宫取宝

X 国王有一个地宫宝库,是 nm 个格子的矩阵,每个格子放一件宝贝,每个宝贝贴着价值标签。 地宫的入口在左上角,出口在右下角。 小明被带到地宫的入口,国王要求他只能向右或向下行走。 走过某个格子时,如果那个…

网络工程师----第二十四天

计算机基础 第一章:概述 互联网的组成: (1)边缘部分:由所有连接在互联网上的主机组成。这部分是用户直接使用的,用来进行通信(传送数据、音频或视频)和资源共享。 (2…

Python大数据分析——Logistic回归模型

Logistic回归模型 概念理论分析模型评估混淆矩阵ROC曲线KS曲线 函数示例 概念 之前的回归的变量是连续的数值变量;而Logistics回归是二元离散值,用来解决二分类问题。 理论分析 上式中的hβ(X)也被称为Loqistic回归模型,它是将线性回归模型…

2-1 EXTI外部中断(gd32)

中断的概念 中断硬件结构/软件结构 EXTI中断 EXTI硬件结构 注:EXTI线在同一时刻只能连接一个GPIO口,如果我们先连接了PA0,然后又连接了PB0那么此时PA0这个IO口就失去作用。 中断触发函数 中断优先级 中断优先级 数值越小优先级越高,抢占优先级…

247 基于matlab的梁的振型仿真

基于matlab的梁的振型仿真。利用有限元理论,求二维梁的固有频率和振型。短边固定,给定长度、横截面积,弹性模量及材料密度已知。并对比理论计算结果进行分析。各参数自己设定。程序已调通,可直接运行。 247 梁的振型仿真 固有频率…

Unity2D 模拟手柄实现玩家移动

1,创建控制器UI 2,挂载脚本 3,脚本编写 基本要素 [Tooltip("玩家游戏体")]public Rigidbody2D player;[Tooltip("玩家速度")]public float speed 1f;[Tooltip("玩家动画")]public Animator animator;public …

企业级复杂前中台项目响应式处理方案

目录 01: 前言 02: 响应式下navigtionBar实现方案分析 数据 视图 小结 03: 抽离公用逻辑,封装系列动作 04: PC端navigationBar私有逻辑处理 05: 分析 navigationBar 闪烁问题 06: 处理 navigationBar 闪烁问题 07: category数据缓存,覆盖…

Android 13 系统自定义安全水印

效果 源码实现 frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java public final void showSafeModeOverlay() {View v LayoutInflater.from(mContext).inflate(com.android.internal.R.layout.safe_mode, null);WindowManager.Layout…

程序员工作中常见问题,你遇到过几个?

在赛博朋克2077玩后感中,我提到,即便是在严谨的机制下,依然可能出现让人匪夷所思或是贻笑大方的问题。 那么今天,就以后端程序员的视角,盘点下从设计开发到上线的常见问题,看看大家中过几个。 01 设计与开…

问题与解决:大华视频后台播放报错

大华播放器接到BI系统后,实时监控视频后台播放一段时间后,报错如下: The play() request was interrupted because video-only background media was paused to save power. 在谷歌浏览器下,直接用代码运行系统,视频在…

python软件测试Jmeter性能测试JDBC Request(结合数据库)的使用详解

这篇文章主要介绍了python软件测试Jmeter性能测试JDBC Request(结合数据库)的使用详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧 JDBC Request 这个 Sampler 可以向数据…

正点原子Linux学习笔记(九)在 LCD 上显示字符

在 LCD 上显示字符 23.1 原始方式:取模显示字符23.2 freetype 简介23.3 freetype 移植下载 FreeType 源码交叉编译 FreeType 源码安装目录下的文件移植到开发板 23.4 freetype 库的使用初始化 FreeType 库加载 face 对象设置字体大小加载字形图像 23.5 示例代码 前面…

FPGA第2篇,FPGA与CPU GPU APU DSP NPU TPU 之间的关系与区别

简介:首先,FPGA与CPU GPU APU NPU TPU DSP这些不同类型的处理器,可以被统称为"处理器"或者"加速器"。它们在计算机硬件系统中承担着核心的计算和处理任务,可以说是系统的"大脑"和"加速引擎&qu…

需求规格说明书设计规范(编制实际项目案例-word)

二、 项目概述 2.1 项目背景 2.2 现状分析 2.2.1 业务现状 2.2.2 系统现状 三、 总体需求 3.1 系统范围 3.2 系统功能 3.3 用户分析 3.4 假设与依赖关系 四、 功能需求 五、 非功能性需求 5.1 用户界面需求 5.2 软硬件环境需求 5.3 产品质量需求 5.4 接口需求 5.5 其他需求 六、…

Django国际化与本地化指南

title: Django国际化与本地化指南 date: 2024/5/12 16:51:04 updated: 2024/5/12 16:51:04 categories: 后端开发 tags: Django-i18n本地化-L10n多语言国际化翻译工具表单验证性能优化 引言 在数字化时代,网站和应用程序必须跨越地域限制,服务于全球…