FLINK SQL UDF

mqiqe2024-10-21 20:38

在Flink SQL中，UDF（User-Defined Function，用户自定义函数）是一种扩展Flink SQL处理能力的机制。通过UDF，用户可以编写自定义的Java或Scala代码，以处理Flink SQL无法直接支持的数据处理逻辑。Flink SQL支持多种类型的UDF，包括标量函数（Scalar Function）、表值函数（Table Function，虽然Flink没有直接命名为UDTF的接口，但FlatTableFunction和TableFunction提供了类似的功能）、聚合函数（Aggregate Function）和表聚合函数（虽然Flink没有直接命名为UDTAGG的接口，但TableAggregateFunction可以看作是一种表级别的聚合函数）。

以下是Flink SQL UDF的一些关键点：

  1. 标量函数（Scalar Function）：
  • 接收一个或多个输入参数，并返回一个单一的结果。
  • 常用于选择列表、过滤条件或计算表达式中。
  • 示例：自定义一个计算两个整数之和的函数。
  1. 表值函数（Table Function，FlatTableFunction/TableFunction）：
  • 接收一个输入行，并返回零个、一个或多个输出行。
  • 常用于需要将输入行拆分成多个输出行的情况。
  • 示例：自定义一个将字符串拆分成单词的函数。
  1. 聚合函数（Aggregate Function）：
  • 对一组输入行进行计算，并返回一个单一的结果。
  • 需要实现累加器逻辑，以处理输入行的累积效应。
  • 示例：自定义一个计算平均值的函数。
  1. 表聚合函数（TableAggregateFunction）：
  • 这是一个更复杂的聚合函数，它返回的是一行或多行结果，而不是单一结果。
  • 通常用于需要基于输入行的集合生成复杂数据结构的情况。
  • 示例：自定义一个计算每个分组中不同值的数量的函数。

要创建和使用Flink SQL中的UDF，需要：

  1. 定义UDF类：
  • 编写一个Java或Scala类，并实现相应的UDF接口（如ScalarFunction、FlatTableFunction、AggregateFunction或TableAggregateFunction）。
  1. 注册UDF：
  • 在Flink SQL CLI、Table API或SQL DDL语句中注册UDF。这通常涉及指定UDF的名称、返回类型以及输入参数类型。
  1. 使用UDF：
  • 在SQL查询中使用注册的UDF名称和参数。Flink SQL解析器将识别UDF，并在执行查询时调用相应的Java或Scala代码。

函数归类

一、标量函数（Scalar Function）

  • 功能特性：
    • 接收一个或多个输入参数，并返回一个单一的结果。
    • 类似于Flink算子的map操作，实现一对一的转换。
  • 使用场景：
    • 常用于选择列表、过滤条件或计算表达式中。
    • 例如，自定义一个将字符串转换为大写的函数，或计算两个数值的和等。

二、表值函数（Table Function，包括TableFunction和FlatTableFunction）

  • 功能特性：
    • 接收一个输入行，并返回零个、一个或多个输出行。
    • 类似于Flink的flatmap操作，实现一对多的转换。
  • 使用场景：
    • 常用于需要将输入行拆分成多个输出行的情况。
    • 例如，自定义一个将字符串拆分成单词的函数，或根据输入行的数据生成多个输出行等。

三、聚合函数（Aggregate Function）

  • 功能特性：
    • 对一组输入行进行计算，并返回一个单一的结果。
    • 类似于Flink的reduce操作，通过聚合操作将多行输出为一个值。
  • 使用场景：
    • 常用于需要对一组数据进行聚合计算的情况。
    • 例如，自定义一个计算平均值的函数，或计算一组数据中的最大值、最小值等。

四、表聚合函数（Table Aggregate Function）

  • 功能特性：
    • 这是一个更复杂的聚合函数，它返回的是一行或多行结果，而不是单一结果。
    • 可以看作是对多行数据进行复杂聚合计算后，生成一个或多个新的行数据。
  • 使用场景：
    • 常用于需要基于输入行的集合生成复杂数据结构的情况。
    • 例如，自定义一个计算每个分组中不同值的数量的函数，或根据输入数据生成一个包含多个统计信息的表等。

函数引用方式

在Flink SQL中，UDF（User-Defined Function，用户自定义函数）函数的引用方式主要有以下几种：

一、通过Table API内联方式引用

  1. 定义UDF类：首先，需要定义一个继承自相应基类（如ScalarFunction、TableFunction等）的UDF类，并实现相应的方法（如eval等）。
  2. 内联调用：在Table API中，可以直接使用call函数内联方式调用UDF，而无需先注册。这种方式适用于临时使用UDF且不需要重复调用的场景。

示例代码：

java 复制代码 
// 自定义标量函数，将输入字符串转换为大写  
public static class ToUpperCase extends ScalarFunction {  
    public String eval(String s) {  
        return s.toUpperCase();  
    }  
}  
  
// 在Table API中使用内联方式调用UDF  
TableResult result = tableEnv.from("example_table")  
    .select(call(ToUpperCase.class, $("name")))  
    .execute();

二、通过Table API先注册后引用

  1. 定义UDF类：与内联方式相同，需要先定义一个UDF类。
  2. 注册UDF：使用TableEnvironment的createTemporarySystemFunction或createTemporaryTableFunction方法将UDF注册到Flink SQL环境中。注册时需要指定UDF的名称和类名。
  3. 引用UDF：在Table API中，通过注册的名称调用UDF。这种方式适用于需要在多个查询中重复使用UDF的场景。

示例代码：

java 复制代码 
// 注册自定义标量函数  
tableEnv.createTemporarySystemFunction("ToUpperCase", ToUpperCase.class);  
  
// 在Table API中使用注册后的UDF  
TableResult result = tableEnv.from("example_table")  
    .select(call("ToUpperCase", $("name")))  
    .execute();

三、通过SQL语句先注册后引用

  1. 定义UDF类：同样需要先定义一个UDF类。
  2. SQL注册：使用SQL的CREATE FUNCTION语句将UDF注册到Flink SQL环境中。注册时需要指定UDF的名称、类名（可能需要包含完整的包名）以及返回类型。
  3. SQL引用：在SQL查询中，通过注册的名称调用UDF。这种方式适用于需要在SQL查询中直接使用UDF的场景。

示例代码：

sql 复制代码 
-- 注册自定义标量函数（假设UDF类在com.example包下）  
CREATE FUNCTION upper_func AS 'com.example.ToUpperCase' RETURNS STRING;  
  
-- 在SQL查询中使用注册后的UDF  
SELECT upper_func(name) FROM example_table;

注意事项

  1. UDF类的要求：UDF类需要是公共的、非抽象的、全局可访问的，并且需要有一个默认的无参构造方法。此外，UDF类中的方法（如eval）也需要是公共的。
  2. 注册名称的唯一性：在同一个Flink SQL环境中，注册的UDF名称需要是唯一的。如果尝试注册一个已经存在的UDF名称，将会导致错误。
  3. UDF的性能：在使用UDF时，需要注意其性能影响。因为UDF是在Flink SQL执行过程中被调用的，所以其执行效率将直接影响到整个查询的性能。因此，在编写UDF时，需要尽量优化其实现逻辑。

函数解析顺序

在Flink SQL中，UDF（User-Defined Function，用户自定义函数）的解析顺序通常与SQL查询的解析和执行流程相关。虽然Flink SQL的官方文档没有直接提及UDF的解析顺序，但可以根据SQL查询的一般解析和执行过程来推断UDF的解析顺序。

首先，需要明确的是，UDF是在SQL查询被解析和执行的过程中被调用的。因此，UDF的解析顺序与SQL查询的解析顺序紧密相关。

在Flink SQL中，SQL查询的解析和执行通常包括以下几个步骤：

  1. 词法分析和语法分析：
    • SQL查询首先被分解为一系列的词法单元（如关键字、标识符、操作符等）。
    • 然后，这些词法单元被组合成语法树，以表示SQL查询的结构和语义。
  2. 语义分析：
    • 在这个阶段，SQL查询的语法树被进一步处理，以验证其语义正确性。
    • 例如，会检查表名、列名是否存在，以及数据类型是否匹配等。
  3. 优化：
    • SQL查询经过优化器进行优化，以提高其执行效率。
    • 优化器可能会对查询进行重写、选择最佳的执行计划等。
  4. 执行：
    • 优化后的查询被传递给执行器进行执行。
    • 在执行过程中，UDF会被调用以处理特定的数据操作或计算。

关于UDF的解析顺序，可以归纳为以下几点：

  • 在语法分析阶段：
    • UDF会被识别为SQL查询中的一部分，并被标记为需要特别处理的函数。
  • 在语义分析阶段：
    • UDF的参数和返回类型会被检查，以确保它们与SQL查询中的其他部分兼容。
    • 如果UDF需要访问特定的表或列，这些表或列的存在性和数据类型也会被验证。
  • 在执行阶段：
    • 当SQL查询的执行器遇到UDF时，它会调用相应的Java或Scala代码来执行UDF的逻辑。
    • UDF的执行顺序取决于SQL查询的执行计划，这通常是由优化器决定的。

系统内置函数

在Flink SQL中，UDF（User-Defined Function，用户自定义函数）与系统内置函数是两个不同的概念。系统内置函数是Flink SQL预先定义好的一系列函数，用于执行常见的操作，如字符串处理、数值计算、日期时间处理等。而UDF则是用户根据特定需求自定义的函数，用于扩展Flink SQL的功能。

关于Flink SQL的系统内置函数，它们涵盖了多个类别，包括但不限于：

  1. 字符串函数：用于处理字符串数据，如UPPER（将字符串转换为大写）、LOWER（将字符串转换为小写）、SUBSTRING（截取字符串）、REPLACE（替换字符串中的子串）等。
  2. 数值函数：用于执行数值计算，如ABS（绝对值）、CEIL（向上取整）、FLOOR（向下取整）、ROUND（四舍五入）等。
  3. 日期和时间函数：用于处理日期和时间数据，如CURRENT_DATE（当前日期）、CURRENT_TIME（当前时间）、CURRENT_TIMESTAMP（当前时间戳）、DATE_FORMAT（格式化日期）等。
  4. 聚合函数：用于对一组数据进行聚合计算，如COUNT（计数）、SUM（求和）、AVG（平均值）、MAX（最大值）、MIN（最小值）等。
  5. 比较函数：用于比较两个值的大小或相等性，如=（等于）、<>（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）等。
  6. 逻辑函数 ：用于执行逻辑运算，如AND（与）、OR（或）、NOT（非）等。
    这些系统内置函数提供了丰富的功能，使得用户可以在Flink SQL中轻松地进行数据处理和分析。同时，由于这些函数是Flink SQL预先定义好的，因此它们的性能和稳定性都得到了保证。

开发UDF之前的须知事项

在开发Flink SQL UDF（User-Defined Function，用户自定义函数）之前，有几个关键须知事项需要牢记，以确保UDF的正确性、性能和安全性。以下是对这些须知事项的详细解释：

1. 集成UDF基类

  • 选择正确的基类：根据UDF的类型（如标量函数、表函数、聚合函数等），选择相应的Flink SQL UDF基类进行继承。例如，对于标量函数，应继承ScalarFunction类。
  • 遵循基类规范：确保遵循所选基类的规范，包括实现必要的方法、处理异常等。

2. 实现UDF执行逻辑函数

  • 明确功能需求：在编写UDF之前，明确其功能需求，确保实现的逻辑与需求一致。
  • 编写高效代码：由于UDF在查询执行过程中被频繁调用，因此应编写高效、简洁的代码，避免不必要的计算和资源消耗。
  • 处理边界情况：考虑并处理可能的边界情况，如空值、异常值等，以确保UDF的健壮性。

3. 注意UDF入参、出参类型推导

  • 类型匹配：确保UDF的入参和出参类型与Flink SQL中的数据类型匹配。如果类型不匹配，可能会导致查询执行失败或结果不正确。
  • 类型推导：了解Flink SQL的类型推导机制，以便在必要时提供类型信息或进行类型转换。

4. 明确UDF输出结果是否是定值

  • 定值与非定值：在Flink SQL中，定值函数是指在给定输入下总是返回相同结果的函数。非定值函数则可能根据上下文（如时间、状态等）返回不同的结果。
  • 性能影响：定值函数通常更容易被优化，因为它们的结果可以被缓存和重用。非定值函数则可能需要更复杂的处理逻辑。
  • 标记定值性：如果可能，通过适当的注解或配置标记UDF的定值性，以便Flink SQL优化器能够利用这一信息。

5. 巧妙运用运行时上下文

  • 访问运行时信息：Flink SQL提供了运行时上下文（如RuntimeContext），允许UDF访问执行时的信息，如任务配置、并行度、状态等。
  • 利用上下文优化：根据运行时信息优化UDF的执行逻辑。例如，根据并行度调整数据处理策略，或利用状态存储中间结果以加速计算。
  • 注意上下文使用限制：了解并遵守运行时上下文的使用限制，以避免潜在的问题。例如，不要在UDF中频繁访问状态或执行阻塞操作，以免影响查询性能。

示例

SQL标量函数（Scalar Function）

在Flink SQL中，标量函数（Scalar Function）是一种用户自定义函数（UDF），它接受一个或多个输入参数，并返回一个单一的值。标量函数通常用于执行数据转换、计算或格式化等操作。

以下是一个简单的Flink SQL标量函数示例，该函数将输入的整数加倍并返回结果：

Java 示例

首先，需要创建一个Java类来定义这个标量函数。这个类将继承ScalarFunction基类，并实现eval方法，该方法将包含函数的执行逻辑。

java 复制代码 
import org.apache.flink.table.functions.ScalarFunction;  
  
public class DoubleValue extends ScalarFunction {  
    public int eval(int value) {  
        return value * 2;  
    }  
}

在这个例子中，DoubleValue类定义了一个名为eval的方法，它接受一个int类型的参数value，并返回value的两倍。

接下来，需要在Flink SQL环境中注册这个UDF，以便在SQL查询中使用它。这通常是在Java代码中完成的，如下所示：

java 复制代码 
// 假设已经有一个TableEnvironment实例名为tableEnv  
tableEnv.createTemporarySystemFunction("double_value", DoubleValue.class);

现在，可以在SQL查询中使用这个名为double_value的UDF了：

sql 复制代码 
SELECT double_value(my_column) AS doubled_value  
FROM my_table;

在这个查询中，double_value函数被应用于my_table中的my_column列，并将结果命名为doubled_value。

SQL表值函数（Table Function）

在Flink SQL中，表值函数（Table Function）是一种用户自定义函数（UDF），它接受一个或多个输入参数，并返回一个表（即多行数据）。表值函数通常用于将复杂的数据结构或逻辑映射到关系表的形式，以便在SQL查询中进行进一步的处理和分析。

以下是一个简单的Flink SQL表值函数示例，该函数将一个输入字符串拆分为单词，并返回包含这些单词的表：

Java 示例

首先，需要创建一个Java类来定义这个表值函数。这个类将继承TableFunction基类，并实现eval方法，该方法负责产生输出表的行。此外，还需要调用collect方法来收集每一行的输出。

java 复制代码 
import org.apache.flink.table.functions.TableFunction;  
import org.apache.flink.types.Row;  
  
import java.util.Arrays;  
  
public class SplitToWords extends TableFunction<Row> {  
    public void eval(String str) {  
        // 将字符串按空格拆分为单词数组  
        String[] words = str.split(" ");  
          
        // 将每个单词封装为Row对象（这里只包含一个字段），并通过collect方法输出  
        for (String word : words) {  
            collect(Row.of(word));  
        }  
    }  
}

在这个例子中，SplitToWords类定义了一个名为eval的方法，它接受一个String类型的参数str，并将str按空格拆分为单词数组。然后，它遍历这个数组，将每个单词封装为一个Row对象（这里Row只包含一个字段，即单词本身），并通过collect方法输出。

接下来，需要在Flink SQL环境中注册这个UDF，以便在SQL查询中使用它。这通常是在Java代码中完成的，如下所示：

java 复制代码 
// 假设已经有一个TableEnvironment实例名为tableEnv  
tableEnv.createTemporarySystemFunction("split_to_words", SplitToWords.class);

现在，可以在SQL查询中使用这个名为split_to_words的UDF了：

sql 复制代码 
-- 假设有一个名为my_table的表，其中有一列名为my_column，包含要拆分的字符串  
SELECT T.*  
FROM my_table,  
     TABLE(split_to_words(my_column)) AS T(word);

在这个查询中，split_to_words函数被应用于my_table中的my_column列。该函数返回一个表，该表被命名为T，并且包含一个名为word的列。然后，使用SELECT语句从这个返回的表中选择所有行。

SQL聚合函数（Aggregate Function）

在Flink SQL中，聚合函数（Aggregate Function）是一种用户自定义函数（UDF），它接受一组输入值，并返回一个单一的值。与标量函数和表值函数不同，聚合函数通常用于对一组行执行计算，并返回一个汇总结果，如总和、平均值、最大值、最小值等。

以下是一个简单的Flink SQL聚合函数示例，该函数计算输入值的加权平均值：

Java 示例

首先，需要创建一个Java类来定义这个聚合函数。这个类将继承AggregateFunction基类，并实现必要的方法：createAccumulator、accumulate、retract（可选，用于处理增量聚合）、merge（用于并行执行时的合并操作）、getResult和resetAccumulator。

java 复制代码 
import org.apache.flink.table.functions.AggregateFunction;  
  
import java.io.Serializable;  
  
public class WeightedAvg implements AggregateFunction<Double, WeightedAvgAccumulator, Double> {  
  
    public static class WeightedAvgAccumulator implements Serializable {  
        private long sumWeight = 0;  
        private double sumValue = 0.0;  
  
        // 累加器重置为初始状态  
        public void reset() {  
            this.sumWeight = 0;  
            this.sumValue = 0.0;  
        }  
  
        // 累加器累加  
        public void add(double value, long weight) {  
            this.sumWeight += weight;  
            this.sumValue += value * weight;  
        }  
  
        // 合并两个累加器  
        public void merge(WeightedAvgAccumulator other) {  
            this.sumWeight += other.sumWeight;  
            this.sumValue += other.sumValue;  
        }  
  
        // 计算最终结果  
        public double getResult() {  
            if (this.sumWeight == 0) {  
                return 0.0; // 避免除以零  
            } else {  
                return this.sumValue / this.sumWeight;  
            }  
        }  
    }  
  
    @Override  
    public WeightedAvgAccumulator createAccumulator() {  
        return new WeightedAvgAccumulator();  
    }  
  
    @Override  
    public void accumulate(WeightedAvgAccumulator accumulator, Double value, Long weight) {  
        accumulator.add(value, weight);  
    }  
  
    // 注意：对于不支持retract的聚合，可以抛出UnsupportedOperationException  
    @Override  
    public void retract(WeightedAvgAccumulator accumulator, Double value, Long weight) {  
        throw new UnsupportedOperationException("This aggregate function does not support retract operation");  
    }  
  
    @Override  
    public WeightedAvgAccumulator merge(WeightedAvgAccumulator a, WeightedAvgAccumulator b) {  
        WeightedAvgAccumulator merged = new WeightedAvgAccumulator();  
        merged.merge(a);  
        merged.merge(b);  
        return merged;  
    }  
  
    @Override  
    public Double getResult(WeightedAvgAccumulator accumulator) {  
        return accumulator.getResult();  
    }  
  
    @Override  
    public void resetAccumulator(WeightedAvgAccumulator accumulator) {  
        accumulator.reset();  
    }  
}

在这个例子中，WeightedAvg类定义了一个名为WeightedAvgAccumulator的内部类，用于存储累加器的状态（即加权总和和权重总和）。然后，WeightedAvg类实现了AggregateFunction接口的方法，以定义聚合函数的行为。

接下来，需要在Flink SQL环境中注册这个UDF，以便在SQL查询中使用它。这通常是在Java代码中完成的，如下所示：

java 复制代码 
// 假设已经有一个TableEnvironment实例名为tableEnv  
tableEnv.createTemporarySystemFunction("weighted_avg", WeightedAvg.class);

但是，请注意，对于聚合函数，通常不会直接这样注册，而是使用Flink SQL的CREATE AGGREGATE FUNCTION语法（如果支持）或通过Table API以不同的方式注册。不过，上面的代码展示了如何定义聚合函数本身。在Flink中，聚合函数通常是通过Table API的aggregate方法或在DDL中定义的。

由于Flink SQL的语法和API可能会随着版本而变化，因此以下是一个更通用的说明，而不是具体的注册代码：

  • 使用Table API ：在构建查询时，使用Table对象的aggregate方法，并传入自定义的聚合函数。

  • 使用DDL ：如果Flink SQL支持CREATE AGGREGATE FUNCTION语法，您可以使用该语法来注册聚合函数。

一旦聚合函数被正确注册，您就可以在SQL查询中使用它了，如下所示（假设它已经被正确注册为weighted_avg）：

sql 复制代码 
SELECT weighted_avg(my_value, my_weight) AS weighted_average  
FROM my_table  
GROUP BY my_group;

在这个查询中，weighted_avg函数被应用于my_table中的my_value和my_weight列，并计算每个组的加权平均值。结果列被命名为weighted_average。

SQL表值聚合函数（Table Aggregate Function）

在Flink SQL中，表值聚合函数（Table Aggregate Function, 简称TAF）是一种较为特殊的用户自定义函数（UDF），它返回一个表作为结果，而不是单个值。表值聚合函数通常用于对输入表进行分组，并对每个分组应用复杂的计算逻辑，最终输出一个包含多个行的结果表。

需要注意的是，Flink SQL本身并不直接支持"表值聚合函数"这一术语所对应的特定函数类型，但可以通过实现TableFunction或TableAggregateFunction（如果Flink版本支持）来模拟类似的行为。然而，TableAggregateFunction在Flink中并不是一个标准的API，它可能是社区扩展或特定版本中的功能。在标准Flink API中，更常见的是使用TableFunction或AggregateFunction与Table API的结合来实现类似的功能。

由于Flink SQL的API可能会随着版本而变化，并且没有直接的"表值聚合函数"API，提供一个使用TableFunction的示例，它可以在某种程度上模拟表值聚合函数的行为。但是，请注意，这个示例并不是真正的表值聚合函数，因为它不直接对分组数据进行聚合并返回表。相反，它展示了如何使用TableFunction来生成一个表作为查询结果的一部分。

使用TableFunction模拟表值聚合函数的行为

以下是一个使用TableFunction的Java示例，它接受一个输入参数并返回一个表（实际上是返回多行结果）：

java 复制代码 
import org.apache.flink.table.functions.TableFunction;  
import org.apache.flink.types.Row;  
  
import java.util.ArrayList;  
import java.util.List;  
  
public class ExplodeListTableFunction implements TableFunction<String, Row> {  
  
    @Override  
    public void eval(String input, Collector<Row> out) {  
        // 假设输入是一个逗号分隔的字符串，将其拆分为一个列表，并为每个元素生成一行  
        String[] elements = input.split(",");  
        for (String element : elements) {  
            // 这里简单地将元素作为一行返回，但可以根据需要构建更复杂的Row对象  
            out.collect(Row.of(element));  
        }  
    }  
}

在Flink SQL中注册并使用这个TableFunction：

sql 复制代码 
-- 假设已经有一个TableEnvironment实例，并且已经通过Java代码注册了ExplodeListTableFunction  
-- CREATE TEMPORARY SYSTEM FUNCTION explode_list AS 'com.example.ExplodeListTableFunction';  
  
-- 使用自定义的TableFunction来"爆炸"一个逗号分隔的字符串列，并生成一个新的表  
SELECT T2.f0 AS element  
FROM my_table,  
     TABLE(explode_list(my_table.my_column)) AS T2(f0);

在这个例子中，explode_list函数接受一个字符串列（假设是一个逗号分隔的列表），并返回一个包含每个元素的表。这不是一个真正的表值聚合函数，因为它没有对分组数据进行聚合。但是，它展示了如何使用TableFunction来生成一个表作为查询结果的一部分。

真正的表值聚合函数（如果支持）

如果Flink版本或扩展支持真正的表值聚合函数（这通常不是标准Flink API的一部分），可能需要实现一个特定的接口，并在DDL中注册这个函数。然而，由于这不是标准功能，无法提供一个具体的示例。

在标准Flink中，要实现类似的功能，通常会：

  1. 使用AggregateFunction来计算每个分组的聚合值。

  2. 使用Table API的join、lateral table或其他操作来将这些聚合值与原始数据或其他表结合起来。

  3. 如果需要更复杂的逻辑，可能需要编写一个自定义的RichFlatMapFunction或ProcessFunction，并在其中处理分组和表值生成。

相关推荐
好看资源平台8 分钟前
网络爬虫——综合实战项目：多平台房源信息采集与分析系统
爬虫·python
进击的六角龙29 分钟前
深入浅出：使用Python调用API实现智能天气预报
开发语言·python
檀越剑指大厂29 分钟前
【Python系列】浅析 Python 中的字典更新与应用场景
开发语言·python
湫ccc37 分钟前
Python简介以及解释器安装（保姆级教学）
开发语言·python
孤独且没人爱的纸鹤40 分钟前
【深度学习】：从人工神经网络的基础原理到循环神经网络的先进技术，跨越智能算法的关键发展阶段及其未来趋势，探索技术进步与应用挑战
人工智能·python·深度学习·机器学习·ai
羊小猪~~44 分钟前
tensorflow案例7--数据增强与测试集, 训练集, 验证集的构建
人工智能·python·深度学习·机器学习·cnn·tensorflow·neo4j
lzhlizihang1 小时前
python如何使用spark操作hive
hive·python·spark
q0_0p1 小时前
牛客小白月赛105 (Python题解) A~E
python·牛客
武子康1 小时前
大数据-230 离线数仓 - ODS层的构建 Hive处理 UDF 与 SerDe 处理 与 当前总结
java·大数据·数据仓库·hive·hadoop·sql·hdfs
极客代码1 小时前
【Python TensorFlow】进阶指南（续篇三）
开发语言·人工智能·python·深度学习·tensorflow
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作