【Spark实践6】特征转换FeatureTransformers实践Scala版--补充算子

本节介绍了用于处理特征的算法，大致可以分为以下几组：

  • 提取（Extraction）：从“原始”数据中提取特征。
  • 转换（Transformation）：缩放、转换或修改特征。
  • 选择（Selection）：从更大的特征集中选择一个子集。
  • 局部敏感哈希（Locality Sensitive Hashing, LSH）：这类算法结合了特征转换的方面与其他算法。

Feature Transformers

IndexToString

对应于StringIndexer，IndexToString将一个标签索引列映射回一个包含原始字符串标签的列。一个常见的用例是使用StringIndexer从标签生成索引，用这些索引训练模型，并使用IndexToString从预测的索引列检索原始标签。然而，你可以自由提供你自己的标签。

示例

基于StringIndexer的例子，假设我们有以下包含列id和categoryIndex的DataFrame：

idcategoryIndex
00.0
12.0
21.0
30.0
40.0
51.0

应用IndexToString，以categoryIndex作为输入列，originalCategory作为输出列，我们能够检索我们的原始标签（它们将从列的元数据中推断出来）：

idcategoryIndexoriginalCategory
00.0a
12.0b
21.0c
30.0a
40.0a
51.0c
import org.apache.spark.ml.attribute.Attribute
import org.apache.spark.ml.feature.{IndexToString, StringIndexer}
import org.apache.spark.sql.SparkSession

object IndexToStringExample {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession
      .builder
      .master("local")
      .appName("IndexToStringExample")
      .getOrCreate()

    val df = spark.createDataFrame(Seq(
      (0, "a"),
      (1, "b"),
      (2, "c"),
      (3, "a"),
      (4, "a"),
      (5, "c")
    )).toDF("id", "category")

    val indexer = new StringIndexer()
      .setInputCol("category")
      .setOutputCol("categoryIndex")
      .fit(df)
    val indexed = indexer.transform(df)

    println(s"Transformed string column '${indexer.getInputCol}' " +
        s"to indexed column '${indexer.getOutputCol}'")
    indexed.show()

    val inputColSchema = indexed.schema(indexer.getOutputCol)
    println(s"StringIndexer will store labels in output column metadata: " +
        s"${Attribute.fromStructField(inputColSchema).toString}\n")

    val converter = new IndexToString()
      .setInputCol("categoryIndex")
      .setOutputCol("originalCategory")

    val converted = converter.transform(indexed)

    println(s"Transformed indexed column '${converter.getInputCol}' back to original string " +
        s"column '${converter.getOutputCol}' using labels in metadata")
    converted.select("id", "categoryIndex", "originalCategory").show()

    spark.stop()
  }
}
OneHotEncoder

One-hot encoding 将一个表示为标签索引的分类特征映射到一个二进制向量中，该向量最多只有一个值为1，表示在所有特征值中存在某个特定的特征值。这种编码允许期望连续特征的算法，如逻辑回归，使用分类特征。对于字符串类型的输入数据，通常首先使用StringIndexer对分类特征进行编码。

OneHotEncoder可以转换多个列，为每个输入列返回一个独热编码的输出向量列。通常使用VectorAssembler将这些向量合并成一个单一的特征向量。

OneHotEncoder支持handleInvalid参数，以选择在转换数据时如何处理无效输入。可用的选项包括’keep’（任何无效输入都被分配到一个额外的分类索引）和’error’（抛出一个错误）。


import org.apache.spark.ml.feature.OneHotEncoder
import org.apache.spark.sql.SparkSession

object OneHotEncoderExample {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession
      .builder
      .master("local")
      .appName("OneHotEncoderExample")
      .getOrCreate()

    val df = spark.createDataFrame(Seq(
      (0.0, 1.0),
      (1.0, 0.0),
      (2.0, 1.0),
      (0.0, 2.0),
      (0.0, 1.0),
      (2.0, 0.0)
    )).toDF("categoryIndex1", "categoryIndex2")

    val encoder = new OneHotEncoder()
      .setInputCols(Array("categoryIndex1", "categoryIndex2"))
      .setOutputCols(Array("categoryVec1", "categoryVec2"))
    val model = encoder.fit(df)

    val encoded = model.transform(df)
    encoded.show()

    spark.stop()
  }
}
VectorIndexer

VectorIndexer帮助在向量数据集中索引分类特征。它既可以自动决定哪些特征是分类的，也可以将原始值转换为类别索引。具体来说，它执行以下操作：

接受一个类型为Vector的输入列和一个参数maxCategories。
根据不同值的数量决定哪些特征应该被视为分类特征，其中最多具有maxCategories的特征被声明为分类特征。
为每个分类特征计算基于0的类别索引。
索引分类特征并将原始特征值转换为索引。
索引分类特征允许算法如决策树和树集合等正确处理分类特征，从而提高性能。
示例

在下面的示例中，我们读入一个标记点的数据集，然后使用VectorIndexer决定哪些特征应该被视为分类特征。我们将分类特征值转换为它们的索引。然后可以将这些转换后的数据传递给处理分类特征的算法，如DecisionTreeRegressor。

import org.apache.spark.ml.feature.VectorIndexer
import org.apache.spark.sql.SparkSession

object VectorIndexerExample {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession
      .builder
      .master("local")
      .appName("VectorIndexerExample")
      .getOrCreate()

    val data = spark.read.format("libsvm").load("data/mllib/sample_libsvm_data.txt")

    val indexer = new VectorIndexer()
      .setInputCol("features")
      .setOutputCol("indexed")
      .setMaxCategories(10)

    val indexerModel = indexer.fit(data)

    val categoricalFeatures: Set[Int] = indexerModel.categoryMaps.keys.toSet
    println(s"Chose ${categoricalFeatures.size} " +
      s"categorical features: ${categoricalFeatures.mkString(", ")}")

    val indexedData = indexerModel.transform(data)
    indexedData.show()

    spark.stop()
  }
}
Interaction

Interaction是一个转换器，它接受向量或双精度值列，并生成一个单独的向量列，包含来自每个输入列的一个值的所有组合的乘积。

例如，如果你有两个向量类型的列，每个列有3个维度作为输入列，那么你将得到一个9维的向量作为输出列。

示例

假设我们有以下带有列“id1”、“vec1”和“vec2”的DataFrame：

id1vec1vec2
1[1.0,2.0,3.0][8.0,4.0,5.0]
2[4.0,3.0,8.0][7.0,9.0,8.0]
3[6.0,1.0,9.0][2.0,3.0,6.0]
4[10.0,8.0,6.0][9.0,4.0,5.0]
5[9.0,2.0,7.0][10.0,7.0,3.0]
6[1.0,1.0,4.0][2.0,8.0,4.0]

应用Interaction到这些输入列后，输出列interactedCol将包含：

id1vec1vec2interactedCol
1[1.0,2.0,3.0][8.0,4.0,5.0][8.0,4.0,5.0,16.0,8.0,10.0,24.0,12.0,15.0]
2[4.0,3.0,8.0][7.0,9.0,8.0][56.0,72.0,64.0,42.0,54.0,48.0,112.0,144.0,128.0]
3[6.0,1.0,9.0][2.0,3.0,6.0][36.0,54.0,108.0,6.0,9.0,18.0,54.0,81.0,162.0]
4[10.0,8.0,6.0][9.0,4.0,5.0][360.0,160.0,200.0,288.0,128.0,160.0,216.0,96.0,120.0]
5[9.0,2.0,7.0][10.0,7.0,3.0][450.0,315.0,135.0,100.0,70.0,30.0,350.0,245.0,105.0]
6[1.0,1.0,4.0][2.0,8.0,4.0][12.0,48.0,24.0,12.0,48.0,24.0,48.0,192.0,96.0]
import org.apache.spark.ml.feature.{Interaction, VectorAssembler}
import org.apache.spark.sql.SparkSession

object InteractionExample {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession
      .builder
      .master("local")
      .appName("InteractionExample")
      .getOrCreate()

    val df = spark.createDataFrame(Seq(
      (1, 1, 2, 3, 8, 4, 5),
      (2, 4, 3, 8, 7, 9, 8),
      (3, 6, 1, 9, 2, 3, 6),
      (4, 10, 8, 6, 9, 4, 5),
      (5, 9, 2, 7, 10, 7, 3),
      (6, 1, 1, 4, 2, 8, 4)
    )).toDF("id1", "id2", "id3", "id4", "id5", "id6", "id7")

    val assembler1 = new VectorAssembler().
      setInputCols(Array("id2", "id3", "id4")).
      setOutputCol("vec1")

    val assembled1 = assembler1.transform(df)

    val assembler2 = new VectorAssembler().
      setInputCols(Array("id5", "id6", "id7")).
      setOutputCol("vec2")

    val assembled2 = assembler2.transform(assembled1).select("id1", "vec1", "vec2")

    val interaction = new Interaction()
      .setInputCols(Array("id1", "vec1", "vec2"))
      .setOutputCol("interactedCol")

    val interacted = interaction.transform(assembled2)

    interacted.show(truncate = false)

    spark.stop()
  }
}
Normalizer

Normalizer是一个转换器，它可以转换包含向量行的数据集，将每个向量规范化为单位范数。它接受参数p，该参数指定用于规范化的p-范数。（默认情况下，p=2。）这种规范化可以帮助标准化输入数据并改善学习算法的行为。

示例

以下示例演示了如何加载libsvm格式的数据集，然后将每行规范化为单位L1范数和单位L∞范数。

import org.apache.spark.ml.feature.Normalizer
import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.sql.SparkSession

object NormalizerExample {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession
      .builder
      .master("local")
      .appName("NormalizerExample")
      .getOrCreate()

    val dataFrame = spark.createDataFrame(Seq(
      (0, Vectors.dense(1.0, 0.5, -1.0)),
      (1, Vectors.dense(2.0, 1.0, 1.0)),
      (2, Vectors.dense(4.0, 10.0, 2.0))
    )).toDF("id", "features")

    val normalizer = new Normalizer()
      .setInputCol("features")
      .setOutputCol("normFeatures")
      .setP(1.0)

    val l1NormData = normalizer.transform(dataFrame)
    println("Normalized using L^1 norm")
    l1NormData.show()

    val lInfNormData = normalizer.transform(dataFrame, normalizer.p -> Double.PositiveInfinity)
    println("Normalized using L^inf norm")
    lInfNormData.show()

    spark.stop()
  }
}
StandardScaler

StandardScaler是一个转换器，用于转换包含向量行的数据集，规范化每个特征以具有单位标准差和/或零均值。它接受以下参数：

withStd：默认为True。将数据缩放到单位标准差。
withMean：默认为False。在缩放之前将数据中心化到均值。这将生成一个密集的输出，因此在应用于稀疏输入时要小心。
StandardScaler是一个估计器，可以在数据集上进行拟合，以产生StandardScalerModel；这相当于计算摘要统计信息。然后模型可以转换数据集中的一个向量列，使其特征具有单位标准差和/或零均值。

请注意，如果一个特征的标准差为零，那么该特征在向量中将返回默认的0.0值。

示例

以下示例演示了如何加载一个libsvm格式的数据集，然后规范化每个特征以具有单位标准差。

import org.apache.spark.ml.feature.StandardScaler
import org.apache.spark.sql.SparkSession

object StandardScalerExample {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession
      .builder
      .master("local")
      .appName("StandardScalerExample")
      .getOrCreate()

    val dataFrame = spark.read.format("libsvm").load("data/mllib/sample_libsvm_data.txt")

    val scaler = new StandardScaler()
      .setInputCol("features")
      .setOutputCol("scaledFeatures")
      .setWithStd(true)
      .setWithMean(false)

    // Compute summary statistics by fitting the StandardScaler.
    val scalerModel = scaler.fit(dataFrame)

    // Normalize each feature to have unit standard deviation.
    val scaledData = scalerModel.transform(dataFrame)
    scaledData.show()

    spark.stop()
  }
}

以下简单介绍以下，就不粘贴代码实例了，如果有需要，请评论区留言，我发你项目

RobustScaler

RobustScaler是一个转换器，它转换包含向量行的数据集，去除中位数并根据特定的分位数范围（默认为IQR：四分位距，即第一四分位数与第三四分位数之间的范围）来缩放数据。它的行为与StandardScaler相似，但是使用中位数和分位数范围代替均值和标准差，这使得它对异常值具有鲁棒性。它接受以下参数：

  1. lower：默认为0.25。用于计算分位数范围的下四分位数，由所有特征共享。
  2. upper：默认为0.75。用于计算分位数范围的上四分位数，由所有特征共享。
  3. withScaling：默认为True。将数据缩放到分位数范围。
  4. withCentering：默认为False。在缩放之前用中位数中心化数据。这将生成一个密集的输出，因此在应用于稀疏输入时要小心。
  5. RobustScaler是一个估计器，可以在数据集上进行拟合，以产生RobustScalerModel；这相当于计算分位数统计信息。然后模型可以转换数据集中的一个向量列，使其特征具有单位分位数范围和/或零中位数。

请注意，如果一个特征的分位数范围为零，那么该特征在向量中将返回默认的0.0值。

MinMaxScaler

MinMaxScaler是一个转换器，它将包含向量行的数据集的每个特征重新缩放到特定范围（通常是[0, 1]）。它接受以下参数：

  1. min：默认为0.0。转换后的下界，由所有特征共享。
  2. max：默认为1.0。转换后的上界，由所有特征共享。
  3. MinMaxScaler在数据集上计算摘要统计，并产生一个MinMaxScalerModel。然后，该模型可以单独转换每个特征，使其位于给定范围内。

特征E的重新缩放值按以下方式计算：
在这里插入图片描述

MaxAbsScaler

MaxAbsScaler是一种转换器，它通过每个特征中的最大绝对值将包含向量行的数据集的每个特征重新缩放到范围[-1, 1]。它不会平移/居中数据，因此不会破坏任何稀疏性。

MaxAbsScaler在数据集上计算摘要统计，并产生一个MaxAbsScalerModel。然后，该模型可以单独将每个特征转换到范围[-1, 1]内。

Bucketizer

Bucketizer是一种转换器，它将连续特征的列转换为特征桶的列，其中桶由用户指定。它接受一个参数：

splits：用于将连续特征映射到桶的参数。有n+1个分割点时，就有n个桶。由分割点x,y定义的桶包含范围[x,y)内的值，除了最后一个桶，它还包括y。分割点应该是严格递增的。必须明确提供-inf和inf的值以覆盖所有Double值；否则，未指定分割点范围外的值将被视为错误。分割点的两个示例是Array(Double.NegativeInfinity, 0.0, 1.0, Double.PositiveInfinity)和Array(0.0, 1.0, 2.0)。
请注意，如果您不知道目标列的上下界限，您应该添加Double.NegativeInfinity和Double.PositiveInfinity作为分割点的边界，以防止潜在的Bucketizer边界异常。

还要注意，您提供的分割点必须是严格递增的顺序，即s0 < s1 < s2 < … < sn。

更多细节可以在Bucketizer的API文档中找到。

ElementwiseProduct

ElementwiseProduct 通过元素间的乘法，将每个输入向量乘以一个给定的“权重”向量。换言之，它通过一个标量乘数来缩放数据集的每一列。这代表了输入向量v与变换向量w之间的哈达马德积（Hadamard product），以产生一个结果向量。
在这里插入图片描述

SQLTransformer

SQLTransformer 实现了由 SQL 语句定义的转换。目前，我们只支持类似 “SELECT … FROM THIS …” 的 SQL 语法，其中 “THIS” 代表输入数据集的底层表格。SELECT 子句指定了在输出中显示的字段、常量和表达式，可以是 Spark SQL 支持的任何 SELECT 子句。用户还可以使用 Spark SQL 内置函数和用户定义的函数（UDFs）对这些选定的列进行操作。例如，SQLTransformer 支持如下语句：

  • SELECT a, a + b AS a_b FROM THIS
  • SELECT a, SQRT(b) AS b_sqrt FROM THIS WHERE a > 5
  • SELECT a, b, SUM© AS c_sum FROM THIS GROUP BY a, b
    示例

假设我们有以下带有列 id、v1 和 v2 的 DataFrame：

idv1v2
01.03.0
22.05.0

这是使用语句 “SELECT *, (v1 + v2) AS v3, (v1 * v2) AS v4 FROM THIS” 的 SQLTransformer 的输出：

idv1v2v3v4
01.03.04.03.0
22.05.07.010.0
VectorAssembler

VectorAssembler 是一个转换器，它将给定的列列表组合成一个单独的向量列。它对于将原始特征和由不同特征转换器生成的特征组合成一个单一的特征向量非常有用，以便训练像逻辑回归和决策树这样的机器学习模型。VectorAssembler 接受以下输入列类型：所有数值类型、布尔类型和向量类型。在每一行中，输入列的值将按指定的顺序连接成一个向量。

VectorSizeHint

有时候，明确指定VectorType列的向量大小是有用的。例如，VectorAssembler 使用其输入列的大小信息来生成其输出列的大小信息和元数据。虽然在某些情况下可以通过检查列的内容来获取这些信息，在流数据框架中，直到流启动之前，内容是不可用的。VectorSizeHint 允许用户明确指定列的向量大小，这样 VectorAssembler 或可能需要知道向量大小的其他转换器就可以使用该列作为输入。

要使用 VectorSizeHint，用户必须设置 inputCol 和 size 参数。将此转换器应用于数据框将产生一个具有更新的元数据的新数据框，为 inputCol 指定了向量大小。对结果数据框进行的下游操作可以使用元数据来获取这个大小。

VectorSizeHint 还可以接受一个可选的 handleInvalid 参数，该参数控制当向量列包含空值或错误大小的向量时的行为。默认情况下，handleInvalid 被设置为“error”，表示应该抛出异常。这个参数也可以设置为“skip”，表示应该从结果数据框中过滤掉包含无效值的行，或者“optimistic”，表示不应该检查列中的无效值，并且应该保留所有行。请注意，使用“optimistic”可能会导致结果数据框处于不一致的状态，这意味着 VectorSizeHint 应用于的列的元数据与该列的内容不匹配。用户应当注意避免这种不一致状态。

QuantileDiscretizer

QuantileDiscretizer 将带有连续特征的列转换为带有分箱类别特征的列。分箱的数量由 numBuckets 参数设置。使用的桶数可能会小于这个值，例如，如果输入的不同值太少，不足以创建足够的不同分位数。

NaN 值：在 QuantileDiscretizer 拟合过程中，NaN 值将从列中移除。这将产生一个 Bucketizer 模型用于预测。在转换过程中，当 Bucketizer 在数据集中发现 NaN 值时，会引发错误，但用户也可以通过设置 handleInvalid 来选择保留或移除数据集中的 NaN 值。如果用户选择保留 NaN 值，这些值将被特殊处理并放入它们自己的桶中，例如，如果使用了 4 个桶，那么非 NaN 数据将被放入 buckets[0-3]，但 NaN 将被计入一个特殊的 bucket[4]。

算法：分箱范围的选择使用了一个近似算法（有关详细描述，请参见 approxQuantile 的文档）。可以用 relativeError 参数控制近似的精度。当设置为零时，将计算精确的分位数（注意：计算精确分位数是一个昂贵的操作）。分箱的下界和上界将是 -Infinity 和 +Infinity，涵盖所有实数值。
Examples

Assume that we have a DataFrame with the columns id, hour:

idhour
018.0
----------
119.0
----------
28.0
----------
35.0
----------
42.2
小时是一种连续特征，具有 Double 类型。我们想要将连续特征转换为分类特征。给定 numBuckets = 3，我们应该得到以下 DataFrame：
idhourresult
018.02.0
----------------
119.02.0
----------------
28.01.0
----------------
35.01.0
----------------
42.20.0
Imputer

Imputer 估计器通过使用所在列的均值、中位数或众数来完成数据集中的缺失值。输入列应为数值类型。目前 Imputer 不支持分类特征，并且可能为包含分类特征的列创建不正确的值。Imputer 可以填充除了‘NaN’之外的自定义值，通过 .setMissingValue(custom_value) 来实现。例如，.setMissingValue(0) 将会填充所有出现的（0）。

请注意，输入列中的所有 null 值都被视为缺失值，因此也会被填充。

示例

假设我们有一个带有列 a 和 b 的 DataFrame：
在这里插入图片描述

在这个例子中，Imputer 将替换所有出现的 Double.NaN（缺失值的默认值）为从相应列的其他值计算出的均值（默认的填充策略）。在这个例子中，列 a 和 b 的替代值分别是 3.0 和 4.0。转换后，输出列中的缺失值将被相关列的替代值所替换。

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

前端常见标签

前端常见标签

<li> (List Item)&#xff1a;定义列表中的一个项目&#xff08;项&#xff09; <ul> (Unordered List)&#xff1a;定义无序列表 <ol> (Ordered List)&#xff1a;定义有序列表 <a> (Anchor Tag)&#xff1a;定义超链接 <ul><li>苹…
阅读更多...
关于华为应用市场上架，申请权限未告知目的被驳回问题的简单处理方式

关于华为应用市场上架，申请权限未告知目的被驳回问题的简单处理方式

关于华为应用市场上架过程中出现的【您的应用在运行时&#xff0c;未同步告知权限申请的使用目的&#xff0c;向用户索取&#xff08;存储、拍照&#xff09;等权限&#xff0c;不符合华为应用市场审核标准。】 使用方式&#xff1a; 1、引入 import permision from "/m…
阅读更多...
paddle环境安装

paddle环境安装

一、paddle环境安装 如pytorch环境安装一样&#xff0c;首先在base环境下创建一个新的环境来安装paddlepaddle框架。首先创建一个新的环境名叫paddle。执行如下命令。 conda create -n paddle python3.8创建好了名叫paddle这个环境以后&#xff0c;进入到这个环境中&#xff…
阅读更多...
【Java 数据结构】排序

【Java 数据结构】排序

排序算法 1. 排序的概念及引用1.1 排序的概念1.2 常见的排序算法 2. 常见排序算法的实现2.1 插入排序2.1.1 直接插入排序2.1.2 希尔排序( 缩小增量排序 ) 2.2 选择排序2.2.1 直接选择排序2.2.2 堆排序 2.3 交换排序2.3.1冒泡排序2.3.2 快速排序2.3.3 快速排序非递归 2.4 归并排…
阅读更多...
【Linux C | 网络编程】netstat 命令图文详解 | 查看网络连接、查看路由表、查看统计数据

【Linux C | 网络编程】netstat 命令图文详解 | 查看网络连接、查看路由表、查看统计数据

&#x1f601;博客主页&#x1f601;&#xff1a;&#x1f680;https://blog.csdn.net/wkd_007&#x1f680; &#x1f911;博客内容&#x1f911;&#xff1a;&#x1f36d;嵌入式开发、Linux、C语言、C、数据结构、音视频&#x1f36d; &#x1f923;本文内容&#x1f923;&a…
阅读更多...
rust gui开发框架选择

rust gui开发框架选择

作为一个系统编程强大语言&#xff0c;怎么能少得了图形界面的开发 实际上写这篇前我也不知道&#xff0c;于是我问了ai大模型&#xff0c;文心3.5和chatgpt4.0 答案实际上不能满意&#xff0c;最后我做了下筛选 参考博文&#xff1a; rust开发环境配置&#xff1a;链接 一、…
阅读更多...
如何选择最适合的服务器

如何选择最适合的服务器

许多朋友想做一些网站&#xff0c;应用&#xff0c;游戏&#xff0c;小程序等等&#xff0c;都需要接触一个基础&#xff0c;就是服务器。服务器相当于一台24小时不关机的联网电脑&#xff0c;浏览网页或者应用相当于用户在访问这台电脑里的文件。那么如何选择最适合自己的服务…
阅读更多...
[C++]类和对象(中)

[C++]类和对象(中)

一:类的六个默认成员函数 如果一个类中什么成员都没有&#xff0c;简称为空类。空类中并不是什么都没有&#xff0c;任何类在什么都不写时&#xff0c;编译器会自动生成以下6个默认成员函数。默认成员函数&#xff1a;用户没有显式实现&#xff0c;编译器会生成的成员函数称为…
阅读更多...
Android Studio非UI线程修改控件——定时器软件

Android Studio非UI线程修改控件——定时器软件

目录 一、UI界面设计 1、UI样式 2、XML代码 二、功能编写 1、定义 2、实现方法 3、功能实现 一、UI界面设计 1、UI样式 2、XML代码 <?xml version"1.0" encoding"utf-8"?> <RelativeLayout xmlns:android"http://schemas.android…
阅读更多...
Interpolator：在Android中方便使用一些常见的CubicBezier贝塞尔曲线动画效果

Interpolator：在Android中方便使用一些常见的CubicBezier贝塞尔曲线动画效果

说明 方便在Android中使用Interpolator一些常见的CubicBezier贝塞尔曲线动画效果。 示意图如下 import android.view.animation.Interpolator import androidx.core.view.animation.PathInterpolatorCompat/*** 参考* android https://yisibl.github.io/cubic-bezier* 实现常…
阅读更多...
【AI数字人-论文】Geneface论文

【AI数字人-论文】Geneface论文

文章目录 前言pipelineaudio-to-motionMotion domain adaptation可视化 Motion-to-imageHead-NeRFTorso-NeRF 结果对比 前言 语音驱动的说话人视频合成旨在根据一段输入的语音&#xff0c;合成对应的目标人脸说话视频。高质量的说话人视频需要满足两个目标&#xff1a; &#…
阅读更多...
算法基础，一维，二维前缀和差分详解

算法基础，一维，二维前缀和差分详解

目录 1.前缀和 1.一维前缀和 例题&#xff1a;【模板】前缀和 2.二维前缀和 例题&#xff1a;【模板】二维前缀和 2.差分 1.一维差分 1.性质&#xff1a;d[i]的前缀和等于a[i] 2.性质&#xff1a;后缀区间修改 例题&#xff1a;【模板】差分 2.二维差分 例题&#x…
阅读更多...
[.NET] 查询当前已安装所有 Win32 与 UWP 应用

[.NET] 查询当前已安装所有 Win32 与 UWP 应用

为了获取当前设备用户已安装的所有应用程序, 一般来讲有两种方案. 一种是通过查询 “shell:AppsFolder” 目录下所有项, 一种是从开始菜单中获取所有快捷方式, 然后加上查询所有已安装的 UWP 应用, 最后得到总列表. 如需代码参考, 请看 github.com/SlimeNull/WindowsAppsQuery …
阅读更多...
Opencv(C++)学习 之RV1126平台的OPENCV交叉编译

Opencv(C++)学习 之RV1126平台的OPENCV交叉编译

本文特点&#xff1a;网上已经有了很多opencv移植RV1106的文章&#xff0c;本文主要记录基于cmake-gui编译&#xff0c;碰到的报错&#xff0c;及解决报错问题的方法&#xff0c;同时简单总结一些配置项相关的知识。 一、环境&#xff1a; ubuntu18 x64 RV1126交叉编译工具链 …
阅读更多...
用HTML5 + JavaScript实现下雪效果

用HTML5 + JavaScript实现下雪效果

用HTML5 JavaScript实现下雪效果 下面是用HTML5 JavaScript实现下雪效果示例&#xff0c;展示了如何使用 HTML5 的 <canvas> 元素以及 JavaScript 来创建下雪效果。效果如下&#xff1a; 源码如下&#xff1a; <!DOCTYPE html> <html lang"en">…
阅读更多...
逸学区块链【solidity】真随机数

逸学区块链【solidity】真随机数

参考Get a Random Number | Chainlink Documentation 但是很贵&#xff0c;价格 Gas Price&#xff1a;当前gas价格&#xff0c;根据网络状况而波动。Callback gas &#xff1a;返回您所请求的随机值时&#xff0c;回调请求消耗的gas 量。验证gas &#xff1a;量gas 用于验证…
阅读更多...
应用层协议 ——— HTTP协议

应用层协议 ——— HTTP协议

应用层协议 ——— HTTP协议 HTTP简介认识URL二、登录信息三、服务器地址四、服务器端口号五、带层次的文件路径六、查询字符串七、片段标识符urlencode和urldecodeHTTP协议格式HTTP请求协议格式HTTP的方法HTTP的状态码HTTP常见的HeaderHTTPS VS HTTP对称加密 VS 非对称加密 HT…
阅读更多...
Unity | YooAssetV2.1.0 + HybridCLR热更新

Unity | YooAssetV2.1.0 + HybridCLR热更新

目录 一、项目更改 二、使用YooAsset热更 1.资源配置 2.资源构建 3.将两个文件夹下的资源上传CDN服务器 4.修改代码 5.运行效果 本文记录利用YooAssetHybridCLR来进行资源和dll的更新。YooAsset使用的是新版V2.1.0。相比于旧版&#xff0c;dll(原生文件)和资源要建两个p…
阅读更多...
zabbix添加主机

zabbix添加主机

zabbix添加主机 查看ip地址 [rootershi ~]# yum -y install net-tools [rootershi ~]# ifconfig eth0 |grep netmask |cut -d " " -f 10 192.168.88.20被监控主机安装zabbix-agent [root20 ~]# mount /dev/cdrom /mnt [root20 ~]# yum -y install wget [root20 ~]…
阅读更多...
conda虚拟环境基础

conda虚拟环境基础

【一文搞定最新版Anaconda】Win11 安装 Anaconda&#xff08;2023.9&#xff09;详解&#xff08;不删除旧版情况下下载、安装、注册、登录、设置环境变量、迁移旧环境、配置修改换源等&#xff09;连接Pycharm_win11安装anaconda-CSDN博客 conda命令大全&#xff08;create/in…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站