create-dwy 0.12.2 → 0.13.0

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/tutorials/futures_minute_frequency_cta_strategy_backtest_example.md

@@ -0,0 +1,295 @@
+---
+source_url: https://docs.dolphindb.cn/zh/tutorials/futures_minute_frequency_cta_strategy_backtest_example.html
+fetched_at: 2026-05-19T09:47:19Z
+category: tutorials
+title: 期货分钟频 CTA 策略回测案例
+sha1: cd52594517c86648459fe13ed505406b1a6f1e90
+---
+
+# 期货分钟频 CTA 策略回测案例
+
+CTA 策略在现代金融市场中扮演着重要角色，通过技术分析和趋势跟踪，其能够帮助用户捕捉市场动向，实现风险对冲和利润最大化。在中高频交易中，CTA
+策略对交易效率、盈利能力的助益尤为明显。
+
+在投入实盘交易之前，利用市场的历史数据对量化中高频策略进行测试和评估是确保交易策略有效性和可行性的重要步骤。DolphinDB
+凭借其高性能计算引擎和强大的数据处理能力，成为中高频交易策略回测的理想选择。在本文中，我们将通过一个期货分钟频率 CTA 策略的回测案例，详细介绍 DolphinDB
+中高频回测引擎的使用，展示其在实际应用中的强大性能。
+
+## 1. 背景介绍
+
+本文将详细展示如何结合多个技术分析指标，如 ATR （平均真实范围）和 RSI （相对强弱指数），实现 CTA 策略的逻辑，包括具体的开仓和止损条件设定。
+
+在介绍期货分钟频 CTA 策略的实现之前，为使读者更好地理解案例，本章将简要介绍 CTA 策略，以及 DolphinDB 提供的中高频回测解决方案。
+
+### 1.1 CTA 策略背景介绍
+
+CTA 投资策略主要通过技术分析和系统化交易方法，在期货和期权市场上进行交易，可分为主观 CTA 和量化 CTA 两大主流策略。主观 CTA
+策略依赖管理人的判断，通过基本面分析和主观判断市场走势来获取收益。而量化 CTA 策略则通过建立量化模型，根据模型产生的买卖信号进行投资决策。
+
+量化 CTA 策略依赖技术分析工具和指标，如移动平均线（MA）、相对强弱指数（RSI）和平均真实范围（ATR）等，来识别市场趋势和交易机会。同时， CTA
+策略高度重视风险管理，通常设定止损和止盈点，以保护投资组合免受重大损失。期货资产买卖的双向交易和 T+0 交易制度优势，使得量化 CTA
+策略能够快速适应市场环境，更直观地捕捉市场变化带来的机遇。因此，当期货市场出现剧烈上涨或下跌波动时，量化CTA策略往往能够有效地从中获利。
+
+从交易策略进行分类，量化 CTA 策略可以分为趋势跟踪、趋势反转、套利对冲。
+
+- 趋势跟踪：主要通过追随已形成的价格趋势获利，在上涨趋势时持有多仓，下跌时持有空仓，当趋势结束时平仓。
+- 趋势反转：通过价格拐点从价格回归过程中获利。信号反转向上时持有多仓，显示价格反转向下时持有空仓，实现回归时进行平仓。
+- 套利对冲：通过对相关品种/合约进行交易。可以做多低估值品种，做空高估值品种；也可以从价格回归中获利，包括期现套利、跨期套利、跨品种套利、跨市场套利等。
+
+本文将通过 DolphinDB 实现期货分钟频率 CTA 的趋势反转策略。
+
+### 1.2 DolphinDB 中高频回测解决方案概述
+
+中高频量化交易策略回测平台的实现主要包括三个重要环节：行情数据按顺序回放，委托订单撮合，以及策略开发与策略回测绩效评估。而在实现中高频策略回测时往往面临以下几个挑战：
+
+首先，海量中高频交易数据对回测引擎的查询与计算性能提出了极高的要求。
+
+其次，为确保策略评估和优化的有效性，回测过程中应尽可能模拟实际的交易过程，例如考虑订单能否成交、成交价格、成交量以及市场冲击等因素。
+
+此外，回测引擎还应具有灵活的架构，能够支持多种交易策略和技术指标的实现，并且易于扩展，以适应不同的市场和交易需求。
+
+针对上述挑战，DolphinDB
+基于其高性能的分布式存储和计算架构，为用户提供了一个易扩展、性能优的中高频量化交易策略回测解决方案。该方案实现了库内行情回放、模拟撮合引擎和事件型中高频回测引擎三大核心组件，支持通过
+DolphinScript、Python 或 C++语言完成中高频策略的研发和测试。具体来说，该方案涵盖以下三个模块：
+
+- 回放功能：支持将一个或多个不同结构的分布式表中的数据严格按照时间或者按指定多列排序顺序**回放**到流表中，因此可以方便地解决因子计算和量化策略研发中研发和生产一体化的问题。
+- 模拟撮合引擎插件：支持沪深交易所 Level-2 逐笔行情和快照行情，实现与交易所一致的 **“价格优先，时间优先”**的高精度的撮合、基于多种行情数据的撮合模式、丰富的可用于模拟实盘环境的撮合配置。
+- 回测插件：用户可以在其中自定义指标，支持基于逐笔、快照、分钟和日频行情进行策略回测，获取回测的收益、持仓、交易明细等信息。其中基于逐笔和快照行情进行高精度策略回测，用户可以实现仿真和回测一体化的策略验证。
+
+值得一提的是，这三个模块化解决方案与外部解决方案兼容性良好。即使用户已经实现了某个环节的解决方案，DolphinDB
+提供的解决方案也可以与其融合成一个完整的回测方案。
+
+## 2. 基于 DolphinDB 的期货 CTA 趋势反转策略实现
+
+本案例基于分钟频率数据，结合 ATR（平均真实范围）和 RSI（相对强弱指数）技术分析指标，实现期货 CTA 趋势反转策略，具体策略逻辑如下：
+
+1. **计算指标：**
+   - 计算1分钟内标的的最高价、最低价与前收盘价的绝对值差（ TR 指标），然后求得 TR 指标的平均值（ATR）。
+   - 用过去10分钟的收盘价数据计算 RSI 指标。
+2. **开仓：**
+   - 当 RSI 值大于 70 且 ATR 大于其10分钟均值时，买入开仓。
+   - 当 RSI 值小于 30 且 ATR 大于其10分钟均值时，卖出开仓。
+3. **止损：**
+   - 持有多仓时，若 K 线达到最高点后回落 0.004，卖平。
+   - 持有空仓时，若 K 线达到最低点后反弹 0.004，买平。
+
+### 2.1 编写自定义策略
+
+**首先，基于分钟频行情数据定义两个重要的技术分析指标：**平均真实范围（ATR）和相对强弱指数（RSI）。ATR 用于衡量市场的波动性，而 RSI
+则用来评估市场的超买或超卖状态。
+
+为了满足使用中高频行情数据计算类似量价因子的需求，DolphinDB
+回测引擎采用了状态响应式引擎。这一引擎能够实现流批统一计算，并有效处理带有状态的高频因子，具体也可以参考[状态响应式引擎用户手册](../funcs/c/createReactiveStateEngine.html)定义相应的指标。以下是定义技术指标 ATR 和 RSI 的代码示例：
+
+```dolphindb
+@state
+def atr(high, low, close, m=14, n=10) {
+    prevClosePrice = prev(close)
+    tr = rowMax([high-low, abs(high-prevClosePrice), abs(low-prevClosePrice)])
+    atr = ema(tr, m)
+    mAtr = mavg(atr, n)
+    return atr, mAtr
+}
+
+@state
+def rsi(close, timePeriod=14) {
+    deltaClose = deltas(close)
+         up = iif(nullCompare( > , deltaClose, 0), deltaClose, 0)
+         down = iif(nullCompare( > , deltaClose, 0), 0, - deltaClose)
+    upAvg = ema(up, timePeriod)
+    downAvg = ema(down, timePeriod)
+    return 100.0 * upAvg / (upAvg + downAvg)
+}
+```
+
+中高频回测中，策略通常是事件驱动的，而一个策略逻辑通常需要涉及多种事件，比如新的行情到来、新的订单成交等等。DolphinDB
+回测引擎采用事件驱动机制，提供了全面的事件函数如策略初始化函数、盘前回调函数、行情回调函数、每日盘后回调函数等，用户可以在相应的回调函数中编写策略逻辑实现相应的策略。此外，自定义回调函数支持
+JIT 技术，可以有效提升策略执行效率。后续本案例将会展示不同的事件函数是如何实现的。
+
+**在策略初始化函数中，首先订阅基于主连复权（平滑）处理之后的最高价、最低价和收盘价行情数据计算 ATR、过去10分钟的 ATR 均值指标和 RSI
+指标。**这里 signal 字段为数组向量，存储的数据分别为主连行情复权之后的最高价，最低价和最新收盘价。subscribeIndicator
+接口获取回测引擎名、需要计算的数据类型、需要计算的指标字典（key 为指标名，用于之后访问；value 为指标计算的元代码），之后计算结果将传入
+`onBar` 等策略回调函数。
+
+```dolphindb
+def initialize(mutable contextDict){
+    d=dict(STRING,ANY)
+    d["ATR"]=<atr(signal[0], signal[1], signal[2], 14,10)[0]>
+    d["mATR"]=<atr(signal[0], signal[1], signal[2], 14,10)[1]>
+    d["RSI"]=<rsi(signal[2], 14)>
+    Backtest::subscribeIndicator(contextDict["engine"], "kline", d)
+}
+```
+
+**在 K 线行情回调函数**
+`onBar`
+**中，系统通过获取订阅的 ATR 和 RSI
+指标生成买入或卖出信号。当存在多仓或者空仓时，若行情出现回调，系统会进行相应的止损操作。**`onBar` 函数的
+*msg* 参数，为回测引擎传来的最新分钟频行情，以及在 `initialize`
+中定义的指标计算结果。*msg* 是一个字典，字典的 key 为期货标的名，而 value
+为这支期货标的对应的行情信息以及指标计算结果。以下代码展示了买入开仓与卖出开仓的判断逻辑：
+
+```dolphindb
+def onBar(mutable contextDict, msg, indicator){
+    lowDict = contextDict["lowPrice"]
+    highDict = contextDict["highPrice"]
+    keys = msg.keys()
+    for (i in keys){
+        istock = msg[i].symbol
+        symbolSource = msg[i].symbolSource
+        pos = Backtest::getPosition(contextDict["engine"], istock)
+        longPos = pos.longPosition
+        shortPos = pos.shortPosition
+        price = msg[i].close
+        atr = indicator[i].ATR
+        matr = indicator[i].mATR
+        rsi = indicator[i].RSI
+        // 没有多头持仓，并且多头趋势时，买入
+        if (longPos < 1 and shortPos < 1 and atr > matr and rsi > contextDict["buySignalRSI"] and matr > 0){
+            Backtest::submitOrder(contextDict["engine"], (istock, symbolSource,
+                                                            contextDict["tradeTime"], 5, price+0.02, 0., 2, 1, 0), "buyOpen")
+            highDict[istock] = price
+            continue
+        }
+
+        // 没有空头持仓，并且空头趋势时，卖出
+        if (longPos < 1 and shortPos < 1 and atr > matr and rsi < contextDict["sellSignalRSI"] and matr > 0){
+            Backtest::submitOrder(contextDict["engine"], (istock,
+                                                            symbolSource, contextDict["tradeTime"], 5, price-0.02, 0., 2, 2, 0), "sellOpen")
+            lowDict[istock] = price
+            continue
+        }
+
+        if (longPos > 0 and price > highDict[istock]){//更新最高价
+                                                      highDict[istock] = max(
+                                                          price, highDict[istock])
+                                                      } else if (longPos > 0 and price <= highDict[istock]*(1-contextDict["closeLine"])){//平仓
+                                                                                                                                         Backtest::submitOrder(contextDict["engine"], (istock, symbolSource,
+                                                                                                                                                                                        contextDict["tradeTime"], 5, price-0.02, 0., 2, 3, 0), "sellClose")
+                                                                                                                                         }
+
+        if (shortPos > 0 and price < lowDict[istock]){//更新最低价
+                                                      lowDict[istock] = min(
+                                                          price, lowDict[istock])
+                                                      } else if (shortPos > 0 and price >= lowDict[istock]*(1+contextDict["closeLine"])){//平仓
+                                                                                                                                         Backtest::submitOrder(contextDict["engine"],
+                                                                                                                                                                 (istock, symbolSource, contextDict["tradeTime"], 5, price+0.02, 0., 2, 4, 0), "buyClose")
+                                                                                                                                         }
+    }
+    contextDict["lowPrice"] = lowDict
+    contextDict["highPrice"] = highDict
+}
+```
+
+这里的 `Backtest::submitOrder` 是回测引擎提供的下单接口：
+
+```dolphindb
+Backtest::submitOrder(engine, msg, label="")
+//engine 引擎实例
+//msg:订单信息元组或表，(股票代码, 下单时间, 订单类型, 订单价格, 订单数量, 买卖方向)
+//label:可选参数，方便用于对订单进行分类
+```
+
+除了根据行情到来编写相应策略外，中高频回测引擎还支持针对委托订单发生订单状态变化、成交、每日盘后进行账户信息统计、策略结束之前处理相应的业务逻辑等编写相应策略。要了解所有中高频回测引擎支持的事件回调函数，请参阅[回测插件接口说明文档](../plugins/backtest.html)。
+
+### 2.2 根据策略设置相应的配置参数
+
+回测的开始与结束日期、初始资金、手续费和印花税、行情类型、订单延时、动态分红除权等均可以通过参数进行配置。这些参数允许用户灵活地调整回测条件，以模拟不同的市场环境和交易策略的效果。本案例为期货策略的回测，因此策略类型参数应设置为
+“future”，以确保回测引擎能够正确识别和处理期货交易的特定规则和逻辑。此外策略逻辑上下文 context
+也可以通过参数设置策略中的全局变量。具体的初始参数配置代码示例如下：
+
+```dolphindb
+userConfig = dict(STRING, ANY)
+userConfig["startDate"] = 2023.02.06
+userConfig["endDate"] = 2023.02.08
+userConfig["strategyGroup"] = "futures"
+userConfig["cash"] = 10000000
+userConfig["commission"] = 1.5
+userConfig["tax"] = 0.0 // useless in future goods backtest engine
+userConfig["dataType"] = 3
+userConfig["msgAsTable"] = false
+userConfig["frequency"] = 0
+userConfig["outputOrderInfo"] = true
+userConfig["depth"] = 5
+userConfig["matchingMode"] = 3
+Context = dict(STRING, ANY)
+Context["buySignalRSI"] = 70.
+Context["sellSignalRSI"] = 30.
+Context["closeLine"] = 0.004
+Context["lowPrice"] = dict(STRING, ANY)
+Context["highPrice"] = dict(STRING, ANY)
+userConfig["context"] = Context
+```
+
+创建期货回测时，需要用户配置期货合约的基本信息表，包括期货合约的合约乘数、交易单位、手续费和手续费的计费方式的（按手数计费或者按成交金额计费）等，具体配置可见[回测引擎接口说明文档](../plugins/backtest.html)。
+
+### 2.3 创建回测引擎
+
+设置引擎名称、模拟交易所名称、引擎配置项、真实行情表的结构和字段映射字典、委托订单的结构和字段映射字典，以及订单详情输出表和合成快照输出表等相应参数之后，通过接口
+`createBacktester` 创建模拟撮合引擎实例。其中，接口
+`createBacktester` 的第四个参数为表示是否开启 JIT 优化。默认值为
+false，表示不开启，若需要开启 JIT 优化，只需要设置此参数为 true 即可。
+
+```dolphindb
+strategyName = "Backtest_test1"
+callbacks = dict(STRING, ANY)
+callbacks["initialize"] = initialize
+callbacks["beforeTrading"] = beforeTrading
+callbacks["onBar"] = onBar
+callbacks["onOrder"] = onOrder
+callbacks["onTrade"] = onTrade
+callbacks["afterTrading"] = afterTrading
+callbacks["finalize"] = finalized
+try{Backtest::dropBacktestEngine(strategyName)}catch(ex){print ex}
+engine = Backtest::createBacktester(strategyName, userConfig, callbacks, , basicInfo)
+```
+
+### 2.4 执行回测引擎
+
+通过 `Backtest::createBacktester` 创建回测引擎之后，可以通过以下方式执行回测。tb
+为相应的分钟频率行情数据，行情数据字段和类型说明参考[回测插件的接口文档](../plugins/backtest.html)。
+
+```dolphindb
+Backtest::appendQuotationMsg(engine, tb)
+```
+
+### 2.5 获取回测结果
+
+回测运行结束之后，可以通过相应的接口获取每日持仓、每日权益、收益概述、成交明细和策略中用户自定义的逻辑上下文。回测插件提供的完整回测结果接口可以参阅[回测插件的接口说明文档](../plugins/backtest.html)。下图为本例获得的每日持仓数据：
+
+![](images/futures_minute_frequency_cta_strategy_backtest_example/2-1.png)
+
+## 3. 性能测试
+
+为了更清晰地展示 DolphinDB 中高频回测引擎的性能，以及开启 JIT 优化对于性能的改进，我们选取了 1 只 AG 主力合约以及 77
+只主力合约2023年2月份的期货1分钟频的两组数据，测试模式设定为单线程，测试结果见表 3-1。
+
+本文使用的测试环境配置为：
+
+- DolphinDB v3.00.1 单节点
+- CPU：Intel(R) Xeon(R) Silver 4216 CPU @ 2.10GHz 64核
+- 内存：400G
+- 硬盘：SSD 12 Gbps
+
+| 标的个数 | 订单数（笔） | 不启用 JIT 优化总耗时（秒） | 启用 JIT 优化总耗时（秒） |
+| --- | --- | --- | --- |
+| 1 只 AG 主力合约 1 个月，10011条数据 | 149 | 0.25 | 0.08 |
+| 77 只主力合约 1 个月，350218条数据 | 2185 | 7.7 | 2.2 |
+
+图 1. 表 3-1：期货分钟频 CTA 策略回测性能测试结果
+
+上述表格展示了 DolphinDB 在处理中高频数据时的效率，以及开启 JIT 优化对于回测性能的提升，充分体现了其在中高频交易策略回测中的优势。
+
+## 4. 总结与展望
+
+本文展示了如何通过 DolphinDB 回测引擎实现期货中高频策略的回测，展现了 DolphinDB
+回测引擎优异的性能、丰富的策略触发机制以及全面的回测结果信息。接下来我们还将陆续发布股票、期权等回测案例，以进一步展示 DolphinDB
+在不同市场和策略中的应用。
+
+## 5. 附录
+
+期货 CTA 策略回测 demo 以及所需数据：
+
+[futureCTAStrategy.dos](https://cdn.dolphindb.cn/zh/tutorials/script/futures_minute_frequency_cta_strategy_backtest_example/futureCTAStrategy.dos)
+
+[futureTestData.csv](https://cdn.dolphindb.cn/zh/tutorials/script/futures_minute_frequency_cta_strategy_backtest_example/futureTestData.csv)

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/tutorials/general_computing.md

@@ -0,0 +1,249 @@
+---
+source_url: https://docs.dolphindb.cn/zh/tutorials/general_computing.html
+fetched_at: 2026-05-19T09:48:52Z
+category: tutorials
+title: 通用计算
+sha1: f408c8254e6b68c994d54223712b94027ec56343
+---
+
+# 通用计算
+
+DolphinDB database不仅可以分布式地存储数据，而且对分布式计算有良好支持。在DolphinDB中，用户可以用系统提供的通用分布式计算框架，通过脚本实现高效的分布式算法，而不需关注具体的底层实现。本文将对DolphinDB通用计算框架中的重要概念和相关函数作出详细解释，并提供丰富的具体使用场景和例子。
+
+## 1. 数据源
+
+数据源(data source)是DolphinDB的通用计算框架中的基本概念。它是一种特殊类型的数据对象，是对数据的元描述。通过执行数据源，用户可以获得诸如表、矩阵、向量等数据实体。在DolphinDB的分布式计算框架中，轻量级的数据源对象而不是庞大的数据实体被传输到远程节点，以用于后续的计算，这大大减少了网络流量。
+
+在DolphinDB中，可使用`sqlDS`函数，基于一个SQL表达式产生数据源。这个函数并不直接对表进行查询，而是返回一个或多个SQL子查询的元语句，即数据源。之后，用户可以使用Map-Reduce框架，传入数据源和计算函数，将任务分发到每个数据源对应的节点，并行地完成计算，然后将结果汇总。
+
+关于几种常用的获得数据源的方法，本文的3.1至3.4节中会详细介绍。
+
+## 2. Map-Reduce框架
+
+Map-Reduce函数是DolphinDB通用分布式计算框架的核心功能。
+
+### 2.1. `mr`函数
+
+DolphinDB的Map-Reduce函数`mr`的语法是 mr(ds, mapFunc, [reduceFunc], [finalFunc], [parallel=true])，它可接受一组数据源和一个mapFunc函数作为参数。它会将计算任务分发到每个数据源所在的结点，通过mapFunc对每个数据源中的数据进行处理。可选参数reduceFunc会将mapFunc的返回值两两做计算，得到的结果再与第三个mapFunc的返回值计算，如此累积计算，将mapFunc的结果汇总。如果有M个map调用，reduce函数将被调用M-1次。可选参数finalFunc对reduceFunc的返回值做进一步处理。
+
+官方手册中有一个通过`mr`执行分布式[最小二乘线性回归的例子](../funcs/m/mr.html)。本文通过以下例子，展示如何用一个`mr`调用实现对分布式表每个分区中的数据随机采样十分之一的功能：
+
+```dolphindb
+// 创建数据库和DFS表
+db = database("dfs://sampleDB", VALUE, `a`b`c`d)
+t = db.createPartitionedTable(table(100000:0, `sym`val, [SYMBOL,DOUBLE]), `tb, `sym)
+n = 3000000
+t.append!(table(rand(`a`b`c`d, n) as sym, rand(100.0, n) as val))
+
+// 定义map函数
+def sampleMap(t) {
+    sampleRate = 0.1
+    rowNum = t.rows()
+    sampleIndex = (0..(rowNum - 1)).shuffle()[0:int(rowNum * sampleRate)]
+    return t[sampleIndex]
+}
+
+ds = sqlDS(<select * from t>)              // 创建数据源
+res = mr(ds, sampleMap, , unionAll)        // 执行计算
+```
+
+在以上的例子中，用户自定义的sampleMap函数接受一个表（即数据源中的数据）作为参数，随机返回其中1/10的行。本例的`mr`函数没有reduceFunc参数，因此将各个map函数的返回值放在一个元组中，传给finalFunc，即`unionAll`。`unionAll`将map函数返回的多张表合并成一个顺序分区的分布式表。
+
+### 2.2. `imr`函数
+
+DolphinDB提供了基于Map-Reduce方法的迭代计算函数`imr`。相比`mr`，它能支持迭代计算，每次迭代使用上一次迭代的结果和输入数据集，因而能支持更多复杂算法的实现。迭代计算需要模型参数的初始值和终止标准。它的语法是 imr(ds, initValue, mapFunc, [reduceFunc], [finalFunc], terminateFunc, [carryover=false])，其中initValue参数是第一次迭代的初值，mapFunc参数是一个函数，接受的参数包括数据源实体，和前一次迭代中最终函数的输出。对于第一次迭代，它是用户给出的初始值。`imr`的 reduceFunc 与`mr`函数中的类似。finalFunc函数接受两个参数，第一个参数是前一次迭代中最终函数的输出。对于第一次迭代，它是用户给出的初始值。第二个参数是调用reduce函数后的输出。terminateFunc参数用于判断迭代是否中止。它接受两个参数。第一个是前一次迭代中reduce函数的输出，第二个是当前迭代中reduce函数的输出。如果它返回true，迭代将会中止。carryover参数表示map函数调用是否生成一个传递给下一次map函数调用的对象。如果carryover为true，那么map函数有3个参数并且最后一个参数为携带的对象，同时map函数的输出结果是一个元组，最后一个元素为携带的对象。在第一次迭代中，携带的对象为NULL。
+
+官方手册中有一个通过`imr`计算分布式数据的中位数的例子。本文将提供一个更加复杂的例子，即用牛顿法实现逻辑回归（Logistic Regression）的计算，展示`imr`在机器学习算法中的应用。
+
+```dolphindb
+def myLrMap(t, lastFinal, yColName, xColNames, intercept) {
+    placeholder, placeholder, theta = lastFinal
+    if (intercept)
+        x = matrix(t[xColNames], take(1.0, t.rows()))
+    else
+        x = matrix(t[xColNames])
+    xt = x.transpose()
+    y = t[yColName]
+    scores = dot(x, theta)
+    p = 1.0 \ (1.0 + exp(-scores))
+    err = y - p
+    w = p * (1.0 - p)
+    logLik = (y * log(p) + (1.0 - y) * log(1.0 - p)).flatten().sum()
+    grad = xt.dot(err)                   // 计算梯度向量
+    wx = each(mul{w}, x)
+    hessian = xt.dot(wx)                 // 计算Hessian矩阵
+    return [logLik, grad, hessian]
+}
+
+def myLrFinal(lastFinal, reduceRes) {
+    placeholder, placeholder, theta = lastFinal
+    logLik, grad, hessian = reduceRes
+    deltaTheta = solve(hessian, grad)    // deltaTheta等于hessian^-1 * grad，相当于解方程hessian * deltaTheta = grad
+    return [logLik, grad, theta + deltaTheta]
+}
+
+def myLrTerm(prev, curr, tol) {
+	placeholder, grad, placeholder = curr
+	return grad.flatten().abs().max() <= tol
+}
+
+def myLr(ds, yColName, xColNames, intercept, initTheta, tol) {
+    logLik, grad, theta = imr(ds, [0, 0, initTheta], myLrMap{, , yColName, xColNames, intercept}, +, myLrFinal, myLrTerm{, , tol})
+    return theta
+}
+```
+
+在上述例子中，map函数为数据源中的数据计算在当前的系数下的梯度向量和Hessian矩阵；reduce函数将map的结果相加，相当于求出整个数据集的梯度向量和Hessian矩阵；final函数通过最终的梯度向量和Hessian矩阵对系数进行优化，完成一轮迭代；terminate函数的判断标准是本轮迭代中梯度向量中最大分量的绝对值是否大于参数tol。
+
+这个例子还可以通过数据源转换操作，进一步优化以提高性能，具体参见后续*数据源转换*小节。
+
+作为经常使用的分析工具，分布式逻辑回归在DolphinDB中作为内置函数`logisticRegression`实现，并提供更多功能。
+
+## 3. 数据源相关函数
+
+DolphinDB提供了以下常用的方法获取数据源：
+
+### 3.1. `sqlDS`函数
+
+`sqlDS`函数根据输入的SQL元代码创建一个数据源列表。 如果SQL查询中的数据表有n个分区，`sqlDS`会生成n个数据源。 如果SQL查询不包含任何分区表，`sqlDS`将返回只包含一个数据源的元组。
+
+`sqlDS`是将SQL表达式转换成数据源的高效方法。用户只需要提供SQL表达式，而不需要关注具体的数据分布，就能利用返回的数据源执行分布式算法。下面提供的例子，展示了利用`sqlDS`对DFS表中的数据执行`olsEx`分布式最小二乘回归的方法。
+
+```dolphindb
+// 创建数据库和DFS表
+db = database("dfs://olsDB", VALUE, `a`b`c`d)
+t = db.createPartitionedTable(table(100000:0, `sym`x`y, [SYMBOL,DOUBLE,DOUBLE]), `tb, `sym)
+n = 3000000
+t.append!(table(rand(`a`b`c`d, n) as sym, 1..n + norm(0.0, 1.0, n) as x, 1..n + norm(0.0, 1.0, n) as y))
+
+ds = sqlDS(<select x, y from t>)    // 创建数据源
+olsEx(ds, `y, `x)                   // 执行计算
+```
+
+### 3.2. `repartitionDS`函数
+
+`sqlDS`的数据源是系统自动根据数据的分区而生成的。有时用户需要对数据源做一些限制，例如，在获取数据时，重新指定数据的分区以减少计算量，或者，只需要一部分分区的数据。`repartitionDS`函数就提供了重新划分数据源的功能。
+
+函数`repartitionDS`根据输入的SQL元代码和列名、分区类型、分区方案等，为元代码生成经过重新分区的新数据源。
+
+以下代码提供了一个`repartitionDS`的例子。在这个例子中，DFS表t中有字段deviceId, time, temperature，分别为symbol, datetime和double类型，数据库采用双层分区，第一层对time按VALUE分区，一天一个分区；第二层对deviceId按HASH分成20个区。
+
+现需要按deviceId字段聚合查询95百分位的temperature。如果直接写查询`select percentile(temperature, 95) from t group by deviceId`，由于`percentile`函数没有Map-Reduce实现，这个查询将无法完成。
+
+一个方案是将所需字段全部加载到本地，计算95百分位，但当数据量过大时，计算资源可能不足。`repartitionDS`提供了一个解决方案：将表基于deviceId按其原有分区方案HASH重新分区，每个新的分区对应原始表中一个HASH分区的所有数据。通过`mr`函数在每个新的分区中计算95百分位的temperature，最后将结果合并汇总。
+
+```dolphindb
+// 创建数据库
+deviceId = "device" + string(1..100000) 
+db1 = database("", VALUE, 2019.06.01..2019.06.30) 
+db2 = database("", HASH, SYMBOL:20) 
+db = database("dfs://repartitionExample", COMPO, [db1, db2]) 
+
+// 创建DFS表
+t = db.createPartitionedTable(table(100000:0, `deviceId`time`temperature, [SYMBOL,DATETIME,DOUBLE]), `tb, `time`deviceId)
+n = 3000000
+t.append!(table(rand(deviceId, n) as deviceId, 2019.06.01T00:00:00 + rand(86400 * 10, n) as time, 60 + norm(0.0, 5.0, n) as temperature))
+
+// 重新分区
+ds = repartitionDS(<select deviceId, temperature from t>, `deviceId)
+// 执行计算
+res = mr(ds, def(t) { return select percentile(temperature, 95) from t group by deviceId}, , unionAll{, false})
+```
+
+这个计算的结果正确性能够保证，因为`repartitionDS`产生的新分区基于deviceId的原有分区，能确保其中各个数据源的deviceId两两不重合，因此只需要将各分区计算结果合并就能取得正确结果。
+
+### 3.3. `textChunkDS`函数
+
+`textChunkDS`函数可以将一个文本文件分成若干个数据源，以便对一个文本文件所表示的数据执行分布式计算。它的语法是：textChunkDS(filename, chunkSize, [delimiter=','], [schema])。其中，filename, delimiter, schema这些参数与`loadText`函数的参数相同。而chunkSize参数表示每个数据源中数据的大小，单位为MB，可以取1到2047的整数。
+
+以下例子是官方手册中`olsEx`例子的另一种实现。它通过`textChunkDS`函数从文本文件中生成若干数据源，每个数据源的大小为100MB，对生成的数据源经过转换后，执行`olsEx`函数，计算最小二乘参数：
+
+```dolphindb
+ds = textChunkDS("c:/DolphinDB/Data/USPrices.csv", 100)
+ds.transDS!(USPrices -> select VOL\SHROUT as VS, abs(RET) as ABS_RET, RET, log(SHROUT*(BID+ASK)\2) as SBA from USPrices where VOL>0)
+rs=olsEx(ds, `VS, `ABS_RET`SBA, true, 2)
+```
+
+其中的数据源转换操作`transDS!`，可以参考后续*数据源转换*小节。
+
+### 3.4. 第三方数据源提供的数据源接口
+
+一些加载第三方数据的插件，例如HDF5，提供了产生数据源的接口。用户可以直接对它们返回的数据源执行分布式算法，而无需先将第三方数据导入内存或保存为分布式表。
+
+DolphinDB的HDF5插件提供了`hdf5DS`函数，用户可以通过设置其dsNum参数，指定需要生成的数据源个数。以下例子从HDF5文件中生成10个数据源，并通过Map-Reduce框架对结果的第1列求样本方差：
+
+```dolphindb
+ds = hdf5::HDF5DS("large_file.h5", "large_table", , 10)
+
+def varMap(t) {
+    column = t.col(0)
+    return [column.sum(), column.sum2(), column.count()]
+}
+
+def varFinal(result) {
+    sum, sum2, count = result
+    mu = sum \ count
+    populationVar = sum2 \ count - mu * mu
+    sampleVar = populationVar * count \ (count - 1)
+    return sampleVar
+}
+
+sampleVar = mr(ds, varMap, +, varFinal)
+```
+
+### 3.5. 数据源缓存
+
+数据源可以有0,1或多个位置。位置为0的数据源是本地数据源。 在多个位置的情况下，这些位置互为备份。系统会随机选择一个位置执行分布式计算。当数据源被指示缓存数据对象时，系统会选择我们上次成功检索数据的位置。
+
+用户可以指示系统对数据源进行缓存或清理缓存。对于迭代计算算法（例如机器学习算法），数据缓存可以大大提高计算性能。当系统内存不足时，缓存数据将被清除。如果发生这种情况，系统可以恢复数据，因为数据源包含所有元描述和数据转换函数。
+
+和数据源缓存相关的函数有：
+
+- `cacheDS!`：指示系统缓存数据源
+- `cacheDSNow`：立即执行并缓存数据源，并返回缓存行的总数
+
+### 3.6. 数据源转换
+
+一个数据源对象还可以包含多个数据转换函数，用以进一步处理所检索到的数据。系统会依次执行这些数据转换函数，一个函数的输出作为下一个函数的输入（和唯一的输入）。
+
+将数据转换函数包含在数据源中，通常比在核心计算操作（即map函数）中对数据源进行转换更有效。如果检索到的数据仅需要一次计算时，没有性能差异，但它对于具有缓存数据对象的数据源的迭代计算会造成巨大的差异。如果转换操作在核心计算操作中，则每次迭代都需要执行转换；如果转换操作在数据源中，则它们只被执行一次。`transDS!`函数提供了转换数据源的功能。
+
+例如，执行迭代机器学习函数`randomForestRegressor`之前，用户可能需要手动填充数据的缺失值（当然，DolphinDB的随机森林算法已经内置了缺失值处理）。此时，可以用`transDS!`对数据源进行如下处理：对每一个特征列，用该列的平均值填充缺失值。假设表中的列x0, x1, x2, x3为自变量，列y为因变量，以下是实现方法：
+
+```dolphindb
+ds = sqlDS(<select x0, x1, x2, x3, y from t>)
+ds.transDS!(def (mutable t) {
+    update t set x0 = nullFill(x0, avg(x0)), x1 = nullFill(x1, avg(x1)), x2 = nullFill(x2, avg(x2)), x3 = nullFill(x3, avg(x3))
+    return t
+})
+
+randomForestRegressor(ds, `y, `x0`x1`x2`x3)
+```
+
+另一个转换数据源的例子是2.2节提到的逻辑回归的脚本实现。在2.2节的实现中，map函数调用中包含了从数据源的表中取出对应列，转换成矩阵的操作，这意味着每一轮迭代都会发生这些操作。而实际上，每轮迭代都会使用同样的输入矩阵，这个转换步骤只需要调用一次。因此，可以用`transDS!`将数据源转换成一个包含x, xt和y矩阵的三元组：
+
+```dolphindb
+def myLrTrans(t, yColName, xColNames, intercept) {
+    if (intercept)
+        x = matrix(t[xColNames], take(1.0, t.rows()))
+    else
+        x = matrix(t[xColNames])
+    xt = x.transpose()
+    y = t[yColName]
+    return [x, xt, y]
+}
+
+def myLrMap(input, lastFinal) {
+    x, xt, y = input
+    placeholder, placeholder, theta = lastFinal
+    // 之后的计算和2.2节相同
+}
+
+// myLrFinal和myLrTerm函数和2.2节相同
+
+def myLr(mutable ds, yColName, xColNames, intercept, initTheta, tol) {
+    ds.transDS!(myLrTrans{, yColName, xColNames, intercept})
+    logLik, grad, theta = imr(ds, [0, 0, initTheta], myLrMap, +, myLrFinal, myLrTerm{, , tol})
+    return theta
+}
+```