先把第一部分计算好。

kappa/data_processing.py

@@ -3,12 +3,12 @@ import pandas as pd
 import queue
 import threading
 from collections import deque
-from scipy.optimize import minimize
-from logger_config import logger
+from scipy.integrate import trapz
 import numpy as np
+from logger_config import logger
 
 # 假设我们有一个数据流，订单簿和成交数据
-order_book_snapshots = deque(maxlen=1000)  # 存储过去10000个订单簿快照
+order_book_snapshots = deque(maxlen=100)  # 存储过去1000个订单簿快照
 
 # 数据积累的阈值
 DATA_THRESHOLD = 20
@@ -41,32 +41,53 @@ def on_message_depth(_ws, message):
         process_depth_data(order_book_snapshots)
 
 
-def phi(k, S, S0):
-    return np.exp(k * (S - S0))
+def calculate_phi(prices, k, S0):
+    """
+    计算 φ(k, ξ) 的值
+    :param prices: 时间序列的价格数据
+    :param k: 参数 k
+    :param S0: 初始价格
+    :return: φ(k, ξ) 的值
+    """
+    price_changes = np.array(prices) - S0
+    exponentials = np.exp(k * price_changes)
+    phi = np.mean(exponentials)
+    return phi
+
 
+def calculate_integral_phi(prices, k, S0, delta_T):
+    """
+    计算 ∫ φ(k, ξ) dξ 的值
+    :param prices: 时间序列的价格数据
+    :param k: 参数 k
+    :param S0: 初始价格
+    :param delta_T: 积分的上限
+    :return: ∫ φ(k, ξ) dξ 的值
+    """
+    # 计算每个时间点的 φ(k, ξ) 值
+    phi_values = [calculate_phi(prices[:i + 1], k, S0) for i in range(len(prices))]
 
-def target_function(params, S_values):
-    A, k = params
-    r = 0
-    for S in S_values:
-        term1 = np.log(phi(k, S, S0))
-        r += (term1 - np.log(A)) ** 2
-    return r
+    # 创建时间点数组
+    time_points = np.linspace(0, delta_T, len(phi_values))
+
+    # 使用梯形法计算积分
+    integral_phi = trapz(phi_values, time_points)
+
+    return integral_phi
 
 
 def process_depth_data(order_book_snapshots):
     global k_initial, A_initial, S0
-    S_values = [((snapshot['bids'][0][0] + snapshot['asks'][0][0]) / 2) for snapshot in order_book_snapshots]  # 使用买价计算
+    S_values = [((snapshot['bids'][0][0] + snapshot['asks'][0][0]) / 2) for snapshot in order_book_snapshots]
 
-    if S0 == 0:
+    if S0 < 0:
         S0 = S_values[0]
 
-    # 使用优化算法最小化目标函数，找到最优的A和k
-    params = np.array([A_initial, k_initial])
-    result = minimize(target_function, params, args=(S_values,))
-    A_opt, k_opt = result.x
-    logger.info("最优参数 A:" + str(A_opt) + " k:" + str(k_opt))
+    delta_T = len(S_values) - 1  # 假设每个时间点间隔为1
+
+    # 计算 ∫ φ(k, ξ) dξ
+    integral_phi_value = calculate_integral_phi(S_values, k_initial, S0, delta_T)
 
-    # 更新初始参数
-    A_initial = A_opt
-    k_initial = k_opt
+    # 计算 log(∫ φ(k, ξ) dξ)
+    log_integral_phi_value = np.log(integral_phi_value)
+    logger.info("log(∫ φ(k, ξ) dξ) 的值: " + str(log_integral_phi_value))