webrtc gcc详解

webrtc的gcc算法(Google Congestion Control),貌似国内很多文章都没有细讲,原理是怎么样的,具体怎么进行计算的。这里详解一下gcc。

gcc算法,主要涉及到:

  • 拥塞控制的关键信息和公式

  • 卡曼滤波算法

  • gcc如何使用卡曼滤波算法

因为知识点有点多,文章有点长,如果感兴趣但不能一次读完,可以先收藏后,有空慢慢看。

1. 前言

对于拥塞控制,webrtc的方案之一是gcc(Google Congestion Control)。具体做法是,接收端监控两个数据,并反馈给发送端。

  • 丢包率: 接收端计算出丢包率,定期发送rtcp rr报文(内有丢包率)给发送端,发送端通过丢包率的大小来决定是否降低编码的bitrate;

  • 基于卡曼滤波的带宽预测: 接收端预测出当前发送端到接收端的带宽,接收端再发送rtcp remb报文(内带有预测带宽)给发送端,发送端根据该预测带宽调整编码的bitrate;

基于丢包率来调整动态编码,是比较简单,很多厂家经常在sfu服务的进行调整,如:如果不是长肥型网络,在丢包率<30%的情况下,rtcp rr中的丢包率和丢包总数欺骗性的填写0,这样发送端(尤其是web端)就不会轻易的降低bitrate,到达测试的良好效果。

但是基于卡曼滤波的带宽预测,就比较复杂,本文主要讲解这部分的原理和实现。

2. 拥塞基础信息与公式

延时是如何测量出来的: 定义报文到达的时间为t(i),报文中的时间戳为T(i)。

图片

那么定义延时: 

d(i) = t(i)-t(i-1)-(T(i)-T(i-1))

在带宽容量C的链路上,传输frame size为L的数据,需要的时间是: ts = L/C

我们对到达时间的间隔进行建模:

         L(i)-L(i-1)d(i) = -------------- + w(i) = dL(i)/C+w(i)             C

上面的公式,i为某个时刻,i-1为上一个时刻。

L(i): 是i时刻接收到的报文长度(这里一般是指某个固定时段接收到的报文size总和)

L(i-1): 是对于i的上一个时刻的报文长度(上一个固定时段收到的报文size总和)

C: 为链路容量带宽;

W(i): 作为一个高斯白噪声,这个参数非常重要。

d(i):是i时刻的延时

划重点:

如果链路使用超载,w(i)增加;

如果链路比较空,w(i)减小;

也就是说,上面两个公式就是预测和估计w(i)是增加了,还是减小了。

总结,关键公式就是这两个:

公式1(测量):d(i) = t(i)-t(i-1)-(T(i)-T(i-1))公式2(估计):                 L(i)-L(i-1)d_est(i) = ------------ + w(i) = dL(i)/C+w(i)                C

公式1: 两个时刻的接收报文的本地时间差值,再减去两个时刻的rtp报文中携带的时间戳的差值,结果等于延时(本地时间与rtp报文中时间戳的单位不一致,需要自己转换一致后再计算)。也就是说d(i)是个测量值,每次收到新的一批报文都能测算得出来对应的延时d(i),所以这里强调d(i)是个测量值。

公式2: 在公式2中,dL(i)是两个时刻收到报文长度的差值,这个也是每收到一批报文后能测算出来的,dL(i)也是个测量值。1/C是个估计值,C是估计的带宽容量,w(i)也是一个估计值。注意,公式左边的d_est(i)也是表示i时刻的延时,不过这个延时是通过右边的估计值计算出来的,也就是这个计算出来的d_est(i)是一个估计值。

最后,我们得到,每个i时刻的测量值d(i),和测量值dL(i),要预测出1/C(i)和w(i),这就是我们的目标。

强调: w(i)增加,表示链路超载;w(i)减小,表示链路轻负荷

卡曼滤波就是要预测出1/C(i)和w(i),并根据根据w(i)是增加或减小,来决定预测带宽是增加还是减小。

小白部分: 既然有了公式1和2,为啥不每次直接计算出延时和带宽的关系,为啥还要引入卡曼滤波算法,弄这么复杂。原因主要是,凡是测试的数据,都会出现测不准,或者有偶尔发生的错误数据(术语叫作噪声),比如某时刻发生抖动,仅仅一批数据产生巨大的延时,但是其实网络是好的,滤波的作用就是过滤出一些无效,错误数据的影响。

先记住这两个公式,后面先打断一下,简单介绍一下卡曼滤波算法。

3. 卡曼滤波算法和示例

针对测试数据,有测试不准确的情况,所以需要在测试数据和估计数据之间进行权衡,卡曼滤波算法就是一个线性的滤波估计算法。

卡曼滤波的5个公式如下(如果看公式有不理解的地方,后面会有个经典的例子,让你理解如何使用这5个公式):

图片

一共5个方程,如上图,左边两个是时间更新方程(预测),右边是测量更新方程(更新/纠正)。

如果第一次接触卡曼滤波算法,可以先熟悉算法,先不研究这5个公式的由来(数学推导),可以作为使用者,只要知道每个变量代表什么意思,如何代入方程,就能满足基础的需求。

头两个预测方程中的参数含义:

A: 状态转移矩阵,就是上一个状态的x变量如何能推导出下一个状态的值。

B:是将输入转换为状态的矩阵;

图片

Q:过程激励噪声协方差(系统过程的协方差)。

后三个测量更新方程的参数含义:

图片

R: 测量噪声协方差。滤波器实际实现时,测量噪声协方差 R一般可以观测得到,是滤波器的已知条件,用户可以根据自己的情况自己设定。

图片

因为公式较多,参数也较多,不容易让人理解,下面举个经典的例子,让你熟悉这些公式和参数。

3.1 卡曼滤波例子(自由落体运动)

假设一个实心球从高空落下,正常来说,我们是能通过速度,加速度g(自由落体加速度9.8米/s),能计算出某个时刻该球的行驶距离速度。

但是因为有空气阻力,或者外界干扰(刮风什么的),实际的速度和距离就不能自己计算出来,需要进行测试。假设实心球自己是能测试出距离和速度的,但是测试仪得出的值可能有误差,需要和计算出来的距离和速度进行折中。

卡曼滤波算法,就是对估计值与测试值进行折中,寻找出真相值的过程。

距离,速度和加速度在时间t上的关系:

s(i) = s(i-1) + v(i-1)*t + 0.5*g*t^2v(i) = v(i-1) + g*t

用线性代数的矩阵来表示就是:

图片

上面这个式子就是卡曼滤波公式1: 

图片

A就是: 

图片

Bu就是:

图片

卡曼滤波的公式2:

图片

其中P是一个协方差矩阵,可以自己初始化一下,协方差矩阵是一个对角矩阵(后续随着数据的输入,P会不断通过公式2和公式5自我更新):

图片

Q是过程激励噪声协方差,表示噪声,可以自己初始化:

图片

卡曼滤波公式3:

图片

其中H是状态变量与测试变量的转换矩阵,因为本例是完全对应的关系,所以这里的H是一个单位矩阵。

图片

R是误差,这里是两个参数s和v,假设测试参数还是比较准,R可以适当的设置小一些(自己更具情况设置):

图片

这样卡曼滤波参数K就可以通过P,H,R三个参数计算出来了。

卡曼滤波公式4:

图片

通过公式3,已经计算出K,参数Z是测试值,本例中Z就是一个向量包含距离和速度(s, v),式子右边的X就是公式1中计算出来的预测值向量(s, v)

图片

公式4非常重要,通过这个公式,对计算估计出来的值,与测试的值进行折中,得出尽可能接近真实的值。

卡曼滤波公式5:

图片

I是单位矩阵,K是公式3计算出来的卡曼滤波增益参数,H是状态变量与测试变量的转换矩阵(本例中是个单位矩阵),式子右边的P是公式2预测的P矩阵。

通过公式5的计算,对P协方差矩阵进行更新。

对上面的5个公式解释后,这里用python进行模拟,代码如下:​​​​​​​

import numpy as npdelta_t = 1 #每次变化是1秒a = 9.8 #重力加速度g# 状态迁移矩阵AA = np.array([[1, delta_t],            [0, 1]])# 协方差矩阵P = np.array([[1, 0.5],              [0.5, 1]])# 预测值与测试值的变换矩阵H = np.array([[1, 0],              [0, 1]])# 过程激励噪声协方差Q = np.array([[0.05, 0.01],              [0.01, 0.05]])# 观测噪声协方差R = np.array([[0.01, 0.01],              [0.01, 0.01],])# 单位矩阵I = np.eye(2)# 每1秒的测试值,第一项是距离,第二项是速度messure_list = np.array([[2.9,  8.8],                        [19.1,  18.1],                        [44.1,  28.9],                        [84.9,  38.7],                        [134,  50],                        [193.4,  62.3],                        [266.1,  72.1],                        [348.6,  83.4],                        [442.4,  95.7],                        [548,  105.5]])# 卡曼滤波公式1: 状态迁移def StatePridict(pos, speed):    x_vector = np.array([[pos], [speed]])    b_u = np.array([[0.5*a*delta_t*delta_t], [a*delta_t]])    result = np.dot(A, x_vector) + b_u    return result# 卡曼滤波公式3: 计算卡曼滤波增益参数Kdef UpdateK():    up_item = np.dot(P, H.transpose())    down_item = np.dot(np.dot(H, P), H.transpose()) + R    inv_item = np.linalg.inv(down_item)    return np.dot(up_item, inv_item)i = 0predict_array = np.array([[],[]])pos_predict = 0speed_predict = 0for z in messure_list:    # 方程1: 状态预测公式(根据距离,速度,时间公式推导)    next = StatePridict(pos_predict, speed_predict)    print("predict next:", next)    # 方程2: 协方差矩阵预测公式    P = np.dot(np.dot(A, P), np.transpose(A)) + Q    print("predict P:", P)    # 方程3: 卡曼滤波增益计算公式    K = UpdateK()    print("update K:", K)    # 方程4: 状态更新公式    messure_item = z.reshape(-1, 1)    print("messure item(", i, "):", messure_item, "shape:", messure_item.shape)    deviation = messure_item - np.dot(H, next)    print("deviation:", deviation)    next = next + np.dot(K, deviation)    predict_array = np.append(predict_array, next)    pos_predict = next[0][0]    speed_predict = next[1][0]    print("update next state pos:", pos_predict, "velocity:", speed_predict)    # 方程5: 协方差更新公司    P = np.dot((I - K * H), P)    print("update P:", P)    i = i + 1    print("")

把这个程序跑起来,观测各个参数的变化过程,仔细阅读,慢慢就理解这5个公式怎么使用。

4. GCC应用卡曼滤波算法

在第2章中,回忆一下这两个公式:​​​​​​​

公式1(测量):d(i) = t(i)-t(i-1)-(T(i)-T(i-1))公式2(估计):                 L(i)-L(i-1)d_est(i) = ------------ + w(i) = dL(i)/C+w(i)                C

每个i时刻的测量值d(i),和测量值dL(i),要预测出1/C(i)和w(i),这就是我们的目标。

w(i)增加超过一个阈值,表示链路超载,w(i)减小了,表示链路轻负荷

卡曼滤波就是要预测出1/C(i)和w(i),并根据根据w(i)是增加或减小,来决定预测带宽是增加还是减小。本节介绍如何预测1/C(i)和w(i)。

回忆一下卡曼滤波的5个公式:

图片

这里,因为向量中的两个参数[1/C w],自身是没法推导自己,所以卡曼滤波的公式1和公式2就省略了,或者说A矩阵就是个单位矩阵,Bu是0,这样预测后的结果还是自己。

这样就直接构造公式3:

X就是[1/C    W]向量的转置

H矩阵= [delta_len    1],delta_len就是两次不同时刻统计收到报文长度的差值。

R是误差,在本例中可以自己设置,在webrtc源码实现中通过UpdateNoiseEstimate函数来更新获取(为了突出主线,这里先省略)。

这样公式3的K就计算出来了。

公式4,更新估计值,

图片

Z就是i时刻的测试数据的延时delay(i),通过d(i) = t(i)-t(i-1)-(T(i)-T(i-1))得到i时刻的延时。

公式5,

图片

等式右边的P是公式2中计算出来的P,因为公式1和2都省略,所以这里值需要确认H就可以

H = [delta_len     1].T

I是单位矩阵。

因为K在公式3中已经计算出来,所以P很容易计算出来。

4.1 python仿真gcc的卡曼滤波

delay_array:表示收到报文测试出来的延时集合

deltalen_array:表示收到报文长度差值的集合

两者作为测试数据,数组下标是一一对应的。​​​​​​​

import numpy as np# d(i) = dL(i)/C + m(i) +v(i) 关键点: 过载的情况,m(i)增加; 轻载的情况,m(i)减小# theta_bar(i) = [1/C(i)  m(i)]^T 其中,带宽C(i)可以设置个初始值,m(i)也设置一个初始值, 后面这两个值就是根据每一次的测试数据来进行预测;# h_bar(i) = [dL(i) 1]^T 其中dL(i)是每次长度变化值,是测试的输入# 方程1: 状态预测公式(根据报文差,带宽公式推导)# 本例没有[1/C(i) m(i)]这个向量自己预测自己的公式,这个公式省略掉,或则说就是自己等于自己# 方程2: 协方差矩阵预测公式# 同方程1,因为没有预测公式,这个方程也省略掉;# 方程3: 卡曼滤波增益计算公式#                              P_(i) * h_bar(i)#     K(i) = --------------------------------------------#                  var_v_hat + h_bar(i)^T * P_(i) * h_bar(i)# 其中P_(i)是协方差矩阵,见方程2; var_v_hat是误差,自己可以初始化一个# 方程4: 状态更新公式# d(i) = h_bar(i)^T * theta_bar(i) + v(i) 两个矩阵的点乘,就是dL(i)/C + m(i)这个式子,v(i)是一个噪声参数(可以初始设定一个较小的值)# z(i) = D(i) - d(i) 这里的D(i)是延时的测试数据,也就是报文来的差值,d(i)是预测数据# z(i) = D(i) - (h_bar(i)^T * theta_bar(i-1) + v(i))# new_theta_bar(i) = theta_bar(i) + K(i) * z(i) 这个式子就是状态更新公式,更新得到新的[1/C(i) m(i)]# 方程5: 协方差更新公式# P(i) = (I - K(i) * h_bar(i)^T) * P_(i) + Q(i) 其中P(i)是协方差矩阵,Q(i)是误差delay_array = [-4.45, 3.92, -3.5, -0.29, 10.77, -6.2, 6.98, -2.75, -8.88, -0.12, 0.78, -0.32, 2.05, -1.61, 3.67, 3.93, 13.23, 51.25, 15.32, 51.05, 124.61, -14.47, 9.43, 43.11, -10.98, 27.03, 34.31, 52.31, 132.39, -9.93, -1.63, 20.47, 54.73, 12.43, 19.86, 0.6, 78.59, -0.2, 35.04, 8.0, 68.9, 6.65, 82.35, 25.6, 108.01, -1.68, 42.52, 7.66, 82.26, 1.68, -0.39, 65.92, 15.35, 77.69, -2.38, -4.94, 9.82, -12.88, 132.41, -0.57, 81.74, 0.13, 33.81, -16.92, -18.68, -1.04, -56.98, 27.08, 0.44, -10.58, -23.03, 23.82, 36.17, -47.1, -140.67, 28.14, -30.56, -72.59, -21.58, -45.59, -87.41, 12.47, 1.0, -3.05, -37.41, -32.05, 22.89, 7.52, 11.13, 34.15, 88.15, -42.39, -2.78, -52.67, -16.58, 5.19, 55.34, 44.73, -13.97, 0.22, 7.63, 27.57, 49.72, 61.74, 18.91, 48.0, -24.09, -6.95, -50.06, 217.24, -62.06, -2.07, 5.83, -3.88, -6.4, 4.35, 39.61, -7.67, 5.65, 9.45, 70.02, -48.47, 35.76, 8.69, -6.4, -4.5, -2.26, -21.2, -53.22, -11.8, 12.25, -8.98, -2.94, -43.99, 1.12, -0.04, -8.08, 14.05, -31.01, -80.63, 94.82, -25.58, -58.55, 47.87, -67.36, 17.57, 4.64, 0.1, 4.71, 7.01, -1.5, -3.25, -1.87, -22.01, 9.57, -8.71, -3.17, -2.12, -36.99, 54.74, -14.71, -8.64, -46.41, 48.79, 5.74, -14.25, -7.76, 30.98, -6.09, 43.08, 16.21, 15.78, -2.86, -63.44, 73.09, -39.69, -50.57, -14.58, -5.34, 5.39, -17.07, -28.32, -15.5, 6.03, -62.54, 1.0, 1.01, -13.52, -32.07, 75.16, -5.2, -0.91, 1.48, 41.72, -21.1, 11.13]deltalen_array = [-98.0, 170.0, -170.0, 314.0, 612.0, -926.0, 873.0, -541.0, 769.0, -1101.0, 0.0, -50.0, 50.0, 182.0, 1407.0, -1589.0, 776.0, -776.0, 55.0, -55.0, 1126.0, -1126.0, 80.0, -80.0, 305.0, -305.0, 278.0, -278.0, 1414.0, -1414.0, 2.0, -2.0, 642.0, -642.0, 387.0, -387.0, 771.0, -771.0, 352.0, -352.0, 746.0, -746.0, 776.0, -776.0, 1420.0, -1420.0, 567.0, -567.0, 923.0, -923.0, 0.0, 660.0, -660.0, 1012.0, -1012.0, 0.0, 0.0, 0.0, 1631.0, -1631.0, 890.0, -890.0, 700.0, -700.0, 0.0, 291.0, -291.0, 412.0, -412.0, 0.0, 75.0, 423.0, -27.0, -434.0, -37.0, 283.0, -115.0, -8.0, -160.0, 160.0, 0.0, -160.0, 0.0, 0.0, 484.0, -484.0, 219.0, -219.0, 0.0, 364.0, 492.0, -856.0, -160.0, 143.0, 17.0, -160.0, 853.0, -184.0, -509.0, 47.0, -47.0, 318.0, 385.0, -32.0, -671.0, 831.0, -831.0, 0.0, 0.0, 2097.0, -2097.0, 0.0, 85.0, -85.0, 0.0, 0.0, 0.0, 160.0, -160.0, 0.0, 1143.0, -983.0, 335.0, -495.0, 0.0, 194.0, -194.0, 0.0, 0.0, 0.0, -17.0, 177.0, -160.0, 0.0, 25.0, -25.0, 0.0, 335.0, 935.0, -1270.0, 941.0, -941.0, 0.0, 835.0, -835.0, 62.0, -62.0, 0.0, 0.0, 194.0, -194.0, 0.0, 0.0, 0.0, 0.0, 0.0, -17.0, 17.0, 0.0, 459.0, -459.0, 160.0, -160.0, 422.0, -422.0, 0.0, 0.0, 208.0, -208.0, 0.0, 946.0, -946.0, 0.0, 242.0, -242.0, 0.0, 0.0, 160.0, -160.0, 0.0, 0.0, 40.0, -40.0, 0.0, 0.0, 0.0, 160.0, -160.0, 320.0, 612.0, -932.0, 0.0, 0.0, 479.0, -479.0, 951.0]C = 50.0 #假设带宽C为50slope_c = 1.0/Cv = 5 #计算延时时候的噪声参数m = 0.1  #m参数,过载的情况,m增加; 轻载的情况,m减小R = 0.05P_Matrix = np.array([[100.0, 0.0],             [0.0, 1e-1]])Q = np.array([[0.05, 0.01],             [0.01, 0.05]])I = np.array([[1, 0],             [0, 1]])def GetK(delta_len, p, r):    h_bar = np.array([[delta_len], [1]])    numerator = np.dot(p, h_bar)    den = np.dot(np.dot(h_bar.T, p), h_bar)    return np.dot(numerator, np.linalg.inv(den)) + r    def DelayUpdate(k, z, delta_len):    h_bar = np.array([[delta_len], [1]])    theta_bar = np.array([[slope_c], [m]])        error = z - (np.dot(h_bar.T, theta_bar) + v)    return theta_bar + k * errordef Update_P(k, p, delta_len):    h_bar = np.array([[delta_len], [1]])    p = p + Q    return np.dot(I - np.dot(k, h_bar.T), p)index = 0for delta_len in deltalen_array:    delay = delay_array[index]    index = index + 1    K = GetK(delta_len, P_Matrix, R)    theta_bar_update = DelayUpdate(K, delay, delta_len)    P_Matrix = Update_P(K, P_Matrix, delta_len)    print("theta_bar_update:", theta_bar_update)

其中GetK函数的生成K卡曼滤波增益参数中,误差参数r是随机设置的。

实际的r是可以通过rtp报文时间戳的差值推导出来,更为精确,详细看这个函数UpdateNoiseEstimate()

4.2 gcc卡曼滤波源码部分

在函数OveruseEstimator::Update()中,

卡曼滤波公式3,计算出K:​​​​​​​

  const double h[2] = {fs_delta, 1.0};  const double Eh[2] = {E_[0][0] * h[0] + E_[0][1] * h[1],                        E_[1][0] * h[0] + E_[1][1] * h[1]};  const double denom = var_noise_ + h[0] * Eh[0] + h[1] * Eh[1];  const double K[2] = {Eh[0] / denom, Eh[1] / denom};

卡曼滤波公式4,计算出1/C,和w,在源码中slope_就是1/C, offset_就是w。residual就是误差部分,其实就是测量值和估计值的差值。​​​​​​​

// residual就是误差部分,其实就是测量值和估计值的差值// 就是python里写的:error = z - (np.dot(h_bar.T, theta_bar) + v)const double residual = t_ts_delta - slope_ * h[0] - offset_;// slope_就是1/Cslope_ = slope_ + K[0] * residual;//offset_比较关键,offset_就是w// w(i)增加,链路使用超载// w(i)减小,链路比较空offset_ = offset_ + K[1] * residual;

上面就是卡曼滤波部分,代码不多,就是原理比较复杂。

4.3 如何判断带宽增减

在4.2中已经能时刻更新offset_的值,也就是我们之前说的公式中:​​​​​​​

            L(i)-L(i-1)d_est(i) = ------------ + w(i) = dL(i)/C+w(i)                C

上面公式中的w(i)就是offset_,

  • w(i)增加(也就是offset_),链路使用超载

  • w(i)减小(也就是offset_),链路比较空

但是如何判断增加和减小多少,这个增量/减量多少认为该做带宽的增减操作呢?

图片

如上图的m(ti)就是m(ti) = std::min(num_of_deltas, kMaxNumDeltas) * offset; 这里的offset就是w(i)

γ (ti )就是threshold_,下面是gcc源码中,函数BandwidthUsage OveruseDetector::Detect(),大于threshold_则带宽过载,小于threshold_则是带宽轻载,否则就保持原状态。​​​​​​​

BandwidthUsage OveruseDetector::Detect() {  const double T = std::min(num_of_deltas, kMaxNumDeltas)                 * offset;  if (T > threshold_) {    hypothesis_ = BandwidthUsage::kBwOverusing;  } else if (T < -threshold_) {    hypothesis_ = BandwidthUsage::kBwUnderusing;  } else {    hypothesis_ = BandwidthUsage::kBwNormal;  }}

通过Detect()返回值,判断是否变换预测带宽。

这个threshold_也是动态变化的,

根据OveruseDetector::UpdateThreshold()函数来更新:​​​​​​​

void OveruseDetector::UpdateThreshold(){  // k_up_(0.0087),  // k_down_(0.039),  const double k = fabs(modified_offset) < threshold_ ?                     k_down_ : k_up_;  const int64_t kMaxTimeDeltaMs = 100;  int64_t time_delta_ms = std::min(now_ms - last_update_ms_,                                kMaxTimeDeltaMs);  threshold_ += k * (fabs(modified_offset) - threshold_)                    * time_delta_ms;  threshold_ = rtc::SafeClamp(threshold_, 6.f, 600.f);  last_update_ms_ = now_ms;}

这里有两个关键的参数k_up_(0.0087), k_down_(0.039)。

k_down_明显要比k_up_大不少,其含义就是预测带宽降低检测的时候,需要更加敏感一些,或者说是需要降低快一些;相反,带宽增减就需要慢一点,稳当一点,保证流畅性。

不少公司都对k_down_和k_up_的参数进行优化,来满足自己动态码率的需求。

5. 总结

最后总结一下,gcc的动态码率依赖两个东西:

  • 丢包率

    丢包率在接收端计算后,通过RTCP rr报文发送给发送端,丢包率>5%,默认就要开始降低编码bitrate;

    如果是sfu服务器模式,sfu代码中可以把rtcp rr中的丢包率和丢包总数根据自定义条件填写0,这样发送端就不会动态调整编码bitrate,达到某些预期的效果

  • 接收端基于延时的卡曼滤波带宽预测

    1) 通过测试delay,和预测的delay来确定卡曼滤波模型,根据模型推导出下一步带宽预测offset。​​​​​​​

公式1(测量):d(i) = t(i)-t(i-1)-(T(i)-T(i-1))公式2(估计):                 L(i)-L(i-1)d_est(i) = ------------ + w(i) = dL(i)/C+w(i)                C

    2) 得到卡曼滤波的变换值offset(也就是上面的w(i)),在根据计算出的threshold,用offset与threshold比较,决定预测带宽应该增加,减少还是不变。

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

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

相关文章

JavaScript 原型链那些事

在讲原型之前我们先来了解一下函数。 在JS中&#xff0c;函数的本质就是对象&#xff0c;它与其他对象不同的是&#xff0c;创建它的构造函数与创建其他对象的构造函数不一样。那产生函数对象的构造函数是什么呢&#xff1f;是一个叫做Function的特殊函数&#xff0c;通过newFu…

Python从入门到放弃——深入研究Print函数

深入浅出Print函数 第一个代码“Hello World” 在正常配置了PyCharm或者Thonny等编辑器之后&#xff0c;我们开始写第一个代码。正常的情况下学习一门编程语言&#xff0c;一般第一个代码都是输出Hello World。那么如何打印Hello World呢&#xff1f; print("Hello Wor…

第六十八回 东平府误陷九纹龙 宋公明义释双枪将-文心大模型ernie-speed免费使用方法

宋江和卢俊义抓阄儿&#xff0c;宋江打东平府&#xff0c;卢俊义打东昌府&#xff0c;谁先打下谁做梁山泊主。宋江带领林冲、花荣、刘唐等二十八人&#xff0c;卢俊义带领吴用、公孙胜、关胜等二十八人。 宋江等人到了东平府外安山镇&#xff0c;郁保四和王定六自告奋勇去下战…

io流 多线程

目录 一、io流 1.什么是io流 2.流的方向 i.输入流 ii.输出流 3.操作文件的类型 i.字节流 1.拷贝 ii.字符流 ​3.字符流输出流出数据 4.字节流和字符流的使用场景 5.练习 6.缓冲流 1.字节缓冲流拷贝文件 2.字符缓冲流特有的方法 1.方法 2.总结 7.转换流基本用法…

掌握MySQL基础命令:数据更新操作详细操作(数据的增删改)

MySQL数据修改是指使用SQL语句&#xff08;如UPDATE、INSERT、DELETE&#xff09;对数据库表中的数据进行更改、添加或删除的操作&#xff0c;常见的操作包括更新表中的记录、插入新记录以及删除现有记录 。 一、数据插入 1插入完整的数据记录 2插入非完整的数据记录 3插入多…

Vulkan 学习(1)---- Vulkan 基本概念和发展历史

目录 Vulkan及其演化史Vulkan 基本概念基本术语 Vulkan 的原理Vulkan应用程序Vulkan的编程模型硬件初始化窗口展示表面资源设置流水线设置描述符和描述符缓冲池基于SPIR-V的着色器流水线管理指令的记录队列的提交 Vulkan及其演化史 目前主流的图形渲染API有OpenGL、OpenGL ES、…

应急响应--网站(web)入侵篡改指南

免责声明:本文... 目录 被入侵常见现象: 首要任务&#xff1a; 分析思路&#xff1a; 演示案例: IIS&.NET-注入-基于时间配合日志分析 Apache&PHP-漏洞-基于漏洞配合日志分析 Tomcat&JSP-弱口令-基于后门配合日志分析 (推荐) Webshell 查杀-常规后门&…

ThinkPHP定时任务是怎样实现的?

接到一个需求&#xff1a;定时检查设备信息&#xff0c;2分钟没有心跳的机器&#xff0c;推送消息给相关人员&#xff0c;用thinkphp5框架&#xff0c;利用框架自带的任务功能与crontab配合来完成定时任务。 第一步&#xff1a;分析需求 先写获取设备信息&#xff0c;2分钟之…

Winform中使用HttpClient实现调用http的post接口并设置传参content-type为application/json示例

场景 Winform中怎样使用HttpClient调用http的get和post接口并将接口返回json数据解析为实体类&#xff1a; Winform中怎样使用HttpClient调用http的get和post接口并将接口返回json数据解析为实体类_winform解析json-CSDN博客 上面使用HttpClient调用post接口时使用的HttpCon…

卷积神经网络基础篇

文章目录 1、卷积层1.1、激活函数1.3、sigmoid1.4、Tanh1.5、ReLU1.6、Leaky ReLU1.7、误差计算 2、池化层3、全连接层4、CNN训练 参考链接1 参考链接2 1、卷积层 卷积层&#xff08;Convolutional layer&#xff09;&#xff0c;这一层就是卷积神经网络最重要的一个层次&…

spRAG框架学习小结

spRAG是什么 spRAG是一个针对非结构化数据的检索引擎。它特别擅长处理对密集文本的复杂查询&#xff0c;比如财务报告、法律文件和学术论文。有两种关键方法用于提高性能&#xff0c;超越了普通的RAG系统&#xff1a; 自动上下文&#xff08;AutoContext&#xff09;&#xff…

几款电脑端能够运行的AI大模型聊天客户端

Ollama Ollama 是一个用于在本地运行和管理大型语言模型的工具。它支持多种流行模型的下载和本地运行&#xff0c;包括 LLaMA-2、CodeLLaMA、Falcon 和 Mistral 。Ollama 提供了一个简单、轻量级和可扩展的解决方案&#xff0c;使得用户可以以最简单快速的方式在本地运行大模型…

中霖教育:二级建造师未注册还需要继续教育吗?

关键词&#xff1a;中霖教育怎么样&#xff0c;中霖教育口碑 如果通过了二级建造师考试但是没有注册&#xff0c;还用继续教育吗? 1. 未注册的二级建造师 二级建造师在其证书获取后三年内没有进行注册时&#xff0c;在申请初始注册之前必须完成规定的本专业继续教育课程。 …

计算样本之间的相似度

文章目录 前言一、距离度量1.1 欧几里得距离&#xff08;Euclidean Distance&#xff09;1.2 曼哈顿距离&#xff08;Manhattan Distance&#xff09;1.3 切比雪夫距离&#xff08;Chebyshev Distance&#xff09;1.4 闵可夫斯基距离&#xff08;Minkowski Distance&#xff09…

Java里的Arrary详解

DK 中提供了一个专门用于操作数组的工具类&#xff0c;即Arrays 类&#xff0c;位于java.util 包中。该类提供了一些列方法来操作数组&#xff0c;如排序、复制、比较、填充等&#xff0c;用户直接调用这些方法即可不需要自己编码实现&#xff0c;降低了开发难度。 java.util.…

时序预测 | Matlab实现TCN-Transformer的时间序列预测

时序预测 | Matlab实现TCN-Transformer的时间序列预测 目录 时序预测 | Matlab实现TCN-Transformer的时间序列预测效果一览基本介绍程序设计 效果一览 基本介绍 基于TCN-Transformer模型的时间序列预测&#xff0c;可以用于做光伏发电功率预测&#xff0c;风速预测&#xff0c;…

XSS平台的搭建

第一步&#xff1a;安装MySQL 数据库 因为xss平台涉及到使用mysql 数据库&#xff0c;在安装之前&#xff0c;先使用docker 安装mysql 数据库。 docker run --name mysqlserver -e MYSQL_ROOT_PASSWORD123 -d -i -p 3309:3306 mysql:5.6 第二步&#xff1a;安装xssplatform…

机械键盘如何挑选

机械键盘的选择是一个关键的决策&#xff0c;因为它直接影响到我们每天的打字体验。在选择机械键盘时&#xff0c;有几个关键因素需要考虑。首先是键盘的键轴类型。常见的键轴类型包括蓝轴、红轴、茶轴和黑轴等。不同的键轴类型具有不同的触发力、触发点和声音。蓝轴通常具有明…

「多模态大模型」解读 | 突破单一文本模态局限

编者按&#xff1a;理想状况下&#xff0c;世界上的万事万物都能以文字的形式呈现&#xff0c;如此一来&#xff0c;我们似乎仅凭大语言模型&#xff08;LLMs&#xff09;就能完成所有任务。然而&#xff0c;理想很丰满&#xff0c;现实很骨感——数据形态远不止文字一种&#…

2024年06月CCF-GESP编程能力等级认证Python编程二级真题解析

本文收录于专栏《Python等级认证CCF-GESP真题解析》&#xff0c;专栏总目录&#xff1a;点这里&#xff0c;订阅后可阅读专栏内所有文章。 一、单选题&#xff08;每题 2 分&#xff0c;共 30 分&#xff09; 第 1 题 小杨父母带他到某培训机构给他报名参加CCF组织的GESP认证…