Flink多流转换（1）—— 分流合流

目录

分流

代码示例

使用侧输出流

合流

联合（Union）

连接（Connect）

简单划分的话，多流转换可以分为“分流”和“合流”两大类

目前分流的操作一般是通过侧输出流（side output）来实现，而合流的算子比较丰富，根据不同的需求可以调用 union、connect、join 以及 coGroup 等接口进行连接合并操作

分流

将一条数据流拆分成完全独立的两条、甚至多条流。也就是基于一个DataStream，得到完全平等的多个子DataStream

代码示例

调用.filter()方法进行筛选，将符合条件的数据拣选出来放到对应的流里

public class SplitStreamByFilter {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        SingleOutputStreamOperator<Event> stream = env.addSource(new ClickSource());
        
        // 筛选Mary的浏览行为放入MaryStream流中
        DataStream<Event> MaryStream = stream.filter(new FilterFunction<Event>() {
            @Override
            public boolean filter(Event value) throws Exception {
                return value.user.equals("Mary");
            }
        });
        
        // 筛选Bob的购买行为放入BobStream流中
        DataStream<Event> BobStream = stream.filter(new FilterFunction<Event>() {
            @Override
            public boolean filter(Event value) throws Exception {
                return value.user.equals("Bob");
            }
        });
        
        // 筛选其他人的浏览行为放入elseStream流中
        DataStream<Event> elseStream = stream.filter(new FilterFunction<Event>() {
            @Override
            public boolean filter(Event value) throws Exception {
                return !value.user.equals("Mary") && !value.user.equals("Bob") ;
            }
        });

        MaryStream.print("Mary pv");
        BobStream.print("Bob pv");
        elseStream.print("else pv");
        
        env.execute();
    }
}

缺点：上述操作将原始流复制了三份，对每一份分别进行筛选，因此代码冗余，不够高效

解决：①.split()方法（但限制了数据类型转换，已经废弃）

②测输出流

使用侧输出流

改进后的代码如下：

public class SplitStreamByOutputTag {
    // 定义输出标签，侧输出流的数据类型为三元组(user, url, timestamp)
    private static OutputTag<Tuple3<String, String, Long>> MaryTag = new OutputTag<Tuple3<String, String, Long>>("Mary-pv"){};
    private static OutputTag<Tuple3<String, String, Long>> BobTag = new OutputTag<Tuple3<String, String, Long>>("Bob-pv"){};
    
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        SingleOutputStreamOperator<Event> stream = env.addSource(new ClickSource());

        SingleOutputStreamOperator<Event> processedStream = stream.process(new ProcessFunction<Event, Event>() {
            @Override
            public void processElement(Event value, Context ctx, Collector<Event> out) throws Exception {
                if (value.user.equals("Mary")){
                    ctx.output(MaryTag, new Tuple3<>(value.user, value.url, value.timestamp));
                } else if (value.user.equals("Bob")){
                    ctx.output(BobTag, new Tuple3<>(value.user, value.url, value.timestamp));
                } else {
                    out.collect(value);
                }
            }
        });

        processedStream.getSideOutput(MaryTag).print("Mary pv");
        processedStream.getSideOutput(BobTag).print("Bob pv");
        processedStream.print("else");

        env.execute();
    }
}

①定义OutputTag作为标签

②使用ctx.output方法将符合筛选条件的数据写入侧输出流

③使用getSideOutput方法从侧输出流中获得数据

合流

对于来源不同的多条流中的数据进行联合处理（与分流相比，合流操作更为普遍）

联合（Union）

直接将多条流合在一起（要求必须流中的数据类型必须相同），合并之后的新流会包括所有流中的元素，数据类型不变

操作：基于 DataStream 直接调用.union()方法

参数：其他 DataStream

返回值：一个 DataStream

stream1.union(stream2, stream3, ...)

水位线时效性：多流合并时处理的时效性是以最慢的那个流为准的（多条流的合并，某种意义上也可以看作是多个并行任务向同一个下游任务汇合的过程）

代码示例：

public class UnionTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);



        SingleOutputStreamOperator<Event> stream1 = env.socketTextStream("hadoop102", 7777)
                .map(data -> {
                    String[] field = data.split(",");
                    return new Event(field[0].trim(), field[1].trim(), Long.valueOf(field[2].trim()));
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(2))
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event element, long recordTimestamp) {
                                return element.timestamp;
                            }
                        })
                );
        stream1.print("stream1");

        SingleOutputStreamOperator<Event> stream2 = env.socketTextStream("hadoop103", 7777)
                .map(data -> {
                    String[] field = data.split(",");
                    return new Event(field[0].trim(), field[1].trim(), Long.valueOf(field[2].trim()));
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(5))
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event element, long recordTimestamp) {
                                return element.timestamp;
                            }
                        })
                );

        stream2.print("stream2");

        // 合并两条流
        stream1.union(stream2)
                .process(new ProcessFunction<Event, String>() {
                    @Override
                    public void processElement(Event value, Context ctx, Collector<String> out) throws Exception {
                        out.collect("水位线：" + ctx.timerService().currentWatermark());
                    }
                })
                .print();


        env.execute();
    }
}

测试：

分别在两台机器上输入以下数据：

hadoop102 ：Alice, ./home, 1000
hadoop103 ：Alice, ./home, 2000
hadoop102 ：Alice, ./home, 3000

水位线的推进如下：

连接（Connect）

连接操作允许流的数据类型不同

连接流（ConnectedStreams）

连接流可以看成是两条流形式上的“统一”，被放在了一个同一个流中；事实上内部仍保持各自的数据形式不变，彼此之间是相互独立的

要想得到新的 DataStream，还需要进一步定义一个“同处理”（co-process）转换操作，用来说明对于不同来源、不同类型的数据，怎样分别进行处理转换、得到统一的输出类型

代码实现

①基于一条 DataStream 调用.connect()方法，传入另外一条 DataStream 作为参数，将两条流连接起来，得到一个 ConnectedStreams

②调用同处理方法得到 DataStream（可以的调用的同处理方法有.map()/.flatMap()，以及.process()方法）

public class ConnectTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStream<Integer> stream1 = env.fromElements(1,2,3);
        DataStream<Long> stream2 = env.fromElements(1L,2L,3L);

        ConnectedStreams<Integer, Long> connectedStreams = stream1.connect(stream2);
        SingleOutputStreamOperator<String> result = connectedStreams.map(new CoMapFunction<Integer, Long, String>() {
            @Override
            public String map1(Integer value) {
                return "Integer: " + value;
            }

            @Override
            public String map2(Long value) {
                return "Long: " + value;
            }
        });

        result.print();

        env.execute();
    }
}

①ConnectedStreams有两个类型参数，分别是stream1和stream2的类型；

②map方法中实现了一个CoMapFunction，表示分别对两条流中的数据执行 map 操作

类型参数<IN1, IN2, OUT>，分别表示第一条流、第二条流，以及合并后的流中的数据类型

这里我们将一条 Integer 流和一条 Long 流合并，转换成 String 输出。所以当遇到第一条流输入的整型值时，调用.map1()；而遇到第二条流输入的长整型数据时，调用.map2():最终都转换为字符串输出，合并成了一条字符串流

③补充：ConnectedStreams 也可以直接调用.keyBy()进行按键分区的操作，得到的还是一个 ConnectedStreams

connectedStreams.keyBy(keySelector1, keySelector2);

传入的参数是两条流中各自的键选择器

这样的操作就是把两条流中key相同的数据放到了一起，然后针对来源的流各自进行处理；

同样也可以在合并之前先使用KeyBy进行分区，然后基于两条KeyedStream进行连接操作；

要注意两条流定义的键的类型必须相同，否则会抛出异常

CoProcessFunction

对于连接流 ConnectedStreams 的处理操作，需要分别定义对两条流的处理转换，因此接口中就会有两个相同的方法需要实现，用数字“1”“2”区分，在两条流中的数据到来时分别调用。我们把这种接口叫作“协同处理函数”（co-process function）

例如：CoMapFunction、CoFlatMapFunction、CoProcessFunction

CoProcessFunction源码如下：

public abstract class CoProcessFunction<IN1, IN2, OUT> extends AbstractRichFunction {
...
public abstract void processElement1(IN1 value, Context ctx, Collector<OUT> out) throws Exception;

public abstract void processElement2(IN2 value, Context ctx, Collector<OUT> out) throws Exception;

public void onTimer(long timestamp, OnTimerContext ctx, Collector<OUT> out) throws Exception {}

public abstract class Context {...}
...
}

简单示例：实现一个实时对账的需求，也就是app 的支付操作和第三方的支付操作的一个双流 Join。App 的支付事件和第三方的支付事件将会互相等待 5 秒钟，如果等不来对应的支付事件，那么就输出报警信息

// 实时对账
public class BillCheckExample {

    public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 来自app的支付日志
        SingleOutputStreamOperator<Tuple3<String, String, Long>> appStream = env.fromElements(
                Tuple3.of("order-1", "app", 1000L),
                Tuple3.of("order-2", "app", 2000L)
        ).assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple3<String, String, Long>>forMonotonousTimestamps()
                .withTimestampAssigner(new SerializableTimestampAssigner<Tuple3<String, String, Long>>() {
                    @Override
                    public long extractTimestamp(Tuple3<String, String, Long> element, long recordTimestamp) {
                        return element.f2;
                    }
                })
        );

        // 来自第三方支付平台的支付日志
        SingleOutputStreamOperator<Tuple4<String, String, String, Long>> thirdpartStream = env.fromElements(
                Tuple4.of("order-1", "third-party", "success", 3000L),
                Tuple4.of("order-3", "third-party", "success", 4000L)
        ).assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple4<String, String, String, Long>>forMonotonousTimestamps()
                .withTimestampAssigner(new SerializableTimestampAssigner<Tuple4<String, String, String, Long>>() {
                    @Override
                    public long extractTimestamp(Tuple4<String, String, String, Long> element, long recordTimestamp) {
                        return element.f3;
                    }
                })
        );

        // 检测同一支付单在两条流中是否匹配，不匹配就报警
        appStream.connect(thirdpartStream)
                .keyBy(data -> data.f0, data -> data.f0)
                .process(new OrderMatchResult())
                .print();

        env.execute();
    }

    // 自定义实现CoProcessFunction
    public static class OrderMatchResult extends CoProcessFunction<Tuple3<String, String, Long>, Tuple4<String, String, String, Long>, String>{
        // 定义状态变量，用来保存已经到达的事件
        private ValueState<Tuple3<String, String, Long>> appEventState;
        private ValueState<Tuple4<String, String, String, Long>> thirdPartyEventState;

        @Override
        public void open(Configuration parameters) throws Exception {
            appEventState = getRuntimeContext().getState(
                    new ValueStateDescriptor<Tuple3<String, String, Long>>("app-event", Types.TUPLE(Types.STRING, Types.STRING, Types.LONG))
            );

            thirdPartyEventState = getRuntimeContext().getState(
                    new ValueStateDescriptor<Tuple4<String, String, String, Long>>("thirdparty-event", Types.TUPLE(Types.STRING, Types.STRING, Types.STRING,Types.LONG))
            );
        }

        @Override
        public void processElement1(Tuple3<String, String, Long> value, Context ctx, Collector<String> out) throws Exception {
            // 看另一条流中事件是否来过
            if (thirdPartyEventState.value() != null){
                out.collect("对账成功：" + value + "  " + thirdPartyEventState.value());
                // 清空状态
                thirdPartyEventState.clear();
            } else {
                // 更新状态
                appEventState.update(value);
                // 注册一个5秒后的定时器，开始等待另一条流的事件
                ctx.timerService().registerEventTimeTimer(value.f2 + 5000L);
            }
        }

        @Override
        public void processElement2(Tuple4<String, String, String, Long> value, Context ctx, Collector<String> out) throws Exception {
            if (appEventState.value() != null){
                out.collect("对账成功：" + appEventState.value() + "  " + value);
                // 清空状态
                appEventState.clear();
            } else {
                // 更新状态
                thirdPartyEventState.update(value);
                // 注册一个5秒后的定时器，开始等待另一条流的事件
                ctx.timerService().registerEventTimeTimer(value.f3 + 5000L);
            }
        }

        @Override
        public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
            // 定时器触发，判断状态，如果某个状态不为空，说明另一条流中事件没来
            if (appEventState.value() != null) {
                out.collect("对账失败：" + appEventState.value() + "  " + "第三方支付平台信息未到");
            }
            if (thirdPartyEventState.value() != null) {
                out.collect("对账失败：" + thirdPartyEventState.value() + "  " + "app信息未到");
            }
            appEventState.clear();
            thirdPartyEventState.clear();
        }
    }}

运行结果如下：

运行结果解析：
①在CoProcessFunction的实现中，声明了两个状态变量用来保存App的支付信息和第三方的支付信息

②App支付信息到达之后，触发processElement1中的操作，检查第三方的支付信息是否已经到达（如果先到达会保存在相应的状态变量中）；如果已经到达，则对账成功；如果没有到达，则等待5s，仍未到达则对账失败；

③第三方支付信息到达后，流程同②

④对于order-1，时间戳为1000的数据（App）到达后，第三方支付信息未到达，等待5s，接着时间戳未3000的数据（第三方）到达后，发现App支付信息已经到达，因此对账成功

⑤对于order-2和order-3，均是等待5s后没有检测到App（第三方）数据到达而发出报警信息

广播连接流（BroadcastConnectedStream）

DataStream 调用.connect()方法时可以传入一个广播流（BroadcastConnectedStream）

这种连接方式往往用在需要动态定义某些规则或配置的场景。因为规则是实时变动的，所以我们可以用一个单独的流来获取规则数据；而这些规则或配置是对整个应用全局有效的，所以不能只把这数据传递给一个下游并行子任务处理，而是要“广播”（broadcast）给所有的并行子任务。而下游子任务收到广播出来的规则，会把它保存成一个状态，这就是所谓的“广播状态”（broadcast state）

如何创建广播流


基于DataStream调用.broadcast()方法，传入一个“映射状态描述器”（MapStateDescriptor），说明状态的名称和类型；

因为广播状态底层是用一个“映射”（map）结构来保存的

MapStateDescriptor<String, Rule> ruleStateDescriptor = new MapStateDescriptor<>(...);
BroadcastStream<Rule> ruleBroadcastStream = ruleStream.broadcast(ruleStateDescriptor);

数据流和广播流的连接

得到“广播连接流”（BroadcastConnectedStream），然后基于广播连接流调用.process()方法，就可以同时获取规则和数据，进行动态处理

DataStream<String> output = stream
 .connect(ruleBroadcastStream)
 .process( new BroadcastProcessFunction<>() {...} );
BroadcastProcessFunction

BroadcastProcessFunction 与 CoProcessFunction 类似，同样是一个抽象类，需要实现两个方法，针对合并的两条流中元素分别定义处理操作。区别在于这里一条流是正常处理数据，而另一条流则是要用新规则来更新广播状态，所以对应的两个方法叫作.processElement()和.processBroadcastElement()

学习课程链接：【尚硅谷】Flink1.13实战教程（涵盖所有flink-Java知识点）_哔哩哔哩_bilibili 

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

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

相关文章

Buy One Carton of Milk（AtCoder abc331B）

Buy One Carton of Milk（AtCoder abc331B）

阅读更多...
Javaweb之SpringBootWeb案例本地存储的详细解析

Javaweb之SpringBootWeb案例本地存储的详细解析

2.2 本地存储 前面我们已分析了文件上传功能前端和后端的基础代码实现&#xff0c;文件上传时在服务端会产生一个临时文件&#xff0c;请求响应完成之后&#xff0c;这个临时文件被自动删除&#xff0c;并没有进行保存。下面呢&#xff0c;我们就需要完成将上传的文件保存在服…
阅读更多...
ZigBee学习(一)

ZigBee学习(一)

文章目录 一、ZigBee介绍1.1 ZigBee协议特点1.2 ZigBee协议体系结构1.3 ZigBee设备类型 二、IEEE 802.15.42.1 物理层2.2 MAC层2.3 如何实现网络和设备寻址2.4 能量管理 三、ZigBee网络拓扑结构四、ZigBee配置参数 一、ZigBee介绍 ZigBee是一种基于IEEE 802.15.4标准的高级通信…
阅读更多...
网易云音乐JS逆向分析

网易云音乐JS逆向分析

文章目录 页面分析抓包分析JS逆向分析代码编写 页面分析 先来分析一下页面 当我们点击播放按钮的时候&#xff0c;音乐开始播放。实际上这个逻辑背后的原理是这个按钮后面对应的是一个url&#xff0c;这个地址是通过ajax来进行局部刷新的。 所以我们可以通过抓包工具&#…
阅读更多...
防御保护----信息安全

防御保护----信息安全

网络安全概述 信息安全&#xff1a;防止任何对数据进行未授权访问的措施&#xff0c;或者防止造成信息有意无意泄露、破坏、丢失等问题的发生&#xff0c;让数据处于远离危险、免于威胁的状态和特性。 网络安全&#xff1a;计算机网络环境下的信息安全。 网络安全背景 网络空间…
阅读更多...
Open3D 与 Point Cloud 处理

Open3D 与 Point Cloud 处理

点云基础3D数据结构点云采集方法点云处理框架点云操作 Open3D基础操作 点云基础 3D数据结构 点云&#xff08;Point Cloud&#xff09;&#xff1a; 点云是由一组离散的点构成的三维数据集合&#xff0c;每个点都包含了坐标信息 (x, y, z) 、颜色 (RGB)、类别 (cls)、强度值等…
阅读更多...
宝塔面板部署MySQL并结合内网穿透实现公网远程访问本地数据库

宝塔面板部署MySQL并结合内网穿透实现公网远程访问本地数据库

文章目录 前言1.Mysql服务安装2.创建数据库3.安装cpolar3.2 创建HTTP隧道 4.远程连接5.固定TCP地址5.1 保留一个固定的公网TCP端口地址5.2 配置固定公网TCP端口地址 前言 宝塔面板的简易操作性,使得运维难度降低,简化了Linux命令行进行繁琐的配置,下面简单几步,通过宝塔面板cp…
阅读更多...
梳理Langchain-Chatchat知识库API接口

梳理Langchain-Chatchat知识库API接口

一.Langchain-Chatchat 知识库管理 1.Langchain-Chatchat 对话和知识库管理界面 Langchain-Chatchat v0.28 完整的界面截图&#xff0c;如下所示&#xff1a; 2.知识库中源文件和向量库 知识库 test 中源文件和向量库的位置&#xff0c;如下所示&#xff1a; 3.知识库表结构 k…
阅读更多...
Glass and Mug(AtCoder abc332_b)

Glass and Mug(AtCoder abc332_b)

阅读更多...
超融合基础架构理解

超融合基础架构理解

1 超融合基础架构 1.1 定义 超融合基础架构&#xff08;Hyper-converged infrastructure&#xff0c;缩写为HCI&#xff09;&#xff0c;是一种集成了存储设备及虚拟运算的信息基础架构框架。在这样的架构环境中&#xff0c;同一厂商的服务器与存储等硬件单元&#xff0c;搭配…
阅读更多...
比较有创意的网站

比较有创意的网站

有创意的网站通常展示了独特的设计、交互或内容。以下是一些备受赞誉的有创意的网站&#xff0c;你可以参考&#xff1a; Awwwards: Awwwards 是一个评选并展示全球最优秀网站的平台。你可以在这里找到很多有创意的网站设计。 Awwwards CSS Design Awards: 类似于Awwwards&…
阅读更多...
若依分页失败，由于对数据二次处理导致total只有十条

若依分页失败，由于对数据二次处理导致total只有十条

在使用若依框架的过程中&#xff0c;如果是查询结果数据直接返回&#xff0c;那么其自带的分页插件可以正常返回数据以及总条数&#xff0c;但若是对数据进行了其他二次处理&#xff0c;再返回就会出现异常&#xff0c;即无论查询了多少条&#xff0c;total都只会显示10&#x…
阅读更多...
实现纯Web语音视频聊天和桌面分享（附源码，PC端+移动端）

实现纯Web语音视频聊天和桌面分享（附源码，PC端+移动端）

在网页里实现文字聊天是比较容易的&#xff0c;但若要实现视频聊天&#xff0c;就比较麻烦了。本文将实现一个纯Web版的视频聊天和桌面分享的Demo&#xff0c;可直接在浏览器中运行&#xff0c;不需要安装任何插件。 一. 主要功能及支持平台 1.本Demo的主要功能有 &#xff…
阅读更多...
CSAPP fall2015 深入理解计算机系统 Cache lab详解

CSAPP fall2015 深入理解计算机系统 Cache lab详解

Cache Lab cache lab 缓存实验 代码下载 从CSAPP上面下载对应的lab代码 http://csapp.cs.cmu.edu/3e/labs.html 环境准备 需要安装 valgrind。可以参考文章Valgrind centos。 安装好以后执行valgrind --version可以看到版本号。 Cache simulator cache simulator not a …
阅读更多...
苹果眼镜（Vision Pro）的开发者指南（5）-主要工具

苹果眼镜（Vision Pro）的开发者指南（5）-主要工具

主要工具有：Xcode、Reality Composer Pro、Unity 第一部分：【用Xcode进行开发】 开始使用Xcode为visionOS进行开发。将向你展示如何在你现有的项目中添加一个visionOS目标，或者构建一个全新的应用，在Xcode预览中创建原型，以及从Reality Composer Pro中导入内容。还将分享…
阅读更多...
c++：string相关的oj题（415. 字符串相加、125. 验证回文串、541. 反转字符串 II、557. 反转字符串中的单词 III）

c++：string相关的oj题（415. 字符串相加、125. 验证回文串、541. 反转字符串 II、557. 反转字符串中的单词 III）

文章目录 1. 415. 字符串相加题目详情代码1思路1代码2思路2 2. 125. 验证回文串题目详情代码1&#xff08;按照要求修改后放到新string里&#xff09;思路1代码2(利用双指针/索引)思路2 3. 541. 反转字符串 II题目详情代码1思路1 4. 557. 反转字符串中的单词 III题目详情代码1&…
阅读更多...
[足式机器人]Part3 机构运动学与动力学分析与建模 Ch00-3(3) 刚体的位形 Configuration of Rigid Body

[足式机器人]Part3 机构运动学与动力学分析与建模 Ch00-3(3) 刚体的位形 Configuration of Rigid Body

本文仅供学习使用&#xff0c;总结很多本现有讲述运动学或动力学书籍后的总结&#xff0c;从矢量的角度进行分析&#xff0c;方法比较传统&#xff0c;但更易理解&#xff0c;并且现有的看似抽象方法&#xff0c;两者本质上并无不同。 2024年底本人学位论文发表后方可摘抄 若有…
阅读更多...
机器学习笔记：地理加权回归（GWR）

机器学习笔记：地理加权回归（GWR）

1 传统的线性回归 机器学习笔记&#xff1a;线性回归_线性回归的读书笔记-CSDN博客 最优的β为&#xff1a; 2 地理加权回归&#xff08;GWR&#xff09; 2.1 模型概述 地理加权回归&#xff08;Geographically Weighted Regression&#xff0c;GWR&#xff09;是传统回归分…
阅读更多...
【算法小记】——机器学习中的概率论和线性代数，附线性回归matlab例程

【算法小记】——机器学习中的概率论和线性代数，附线性回归matlab例程

内容包含笔者个人理解&#xff0c;如果错误欢迎评论私信告诉我 线性回归matlab部分参考了up主DR_CAN博士的课程 机器学习与概率论 在回归拟合数据时&#xff0c;根据拟合对象&#xff0c;可以把分类问题视为一种简答的逻辑回归。在逻辑回归中算法不去拟合一段数据而是判断输入…
阅读更多...
5G-A：“繁花”盛开在2024

5G-A：“繁花”盛开在2024

2019年&#xff0c;我国正式发牌5G&#xff0c;开启5G商用新时代。通信技术十年一代&#xff0c;五年过去了&#xff0c;5G是否要进入“半代更迭”阶段&#xff1f; 2024年被视为5G-A商用元年&#xff0c;是5G走向6G的关键一跃。5G-A以R18为演进起点&#xff0c;在连接速率、网…
阅读更多...
最新文章

Copyright @ 2022~2023

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