diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 00000000..e69de29b diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 00000000..f653c065 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,28 @@ +--- +name: Bug report +about: Create a bug report to help us improve gQuant +title: "[BUG]" +labels: "? - Needs Triage, bug" +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**Steps/Code to reproduce bug** +Follow this guide http://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports to craft a minimal bug report. This helps us reproduce the issue you're having and resolve the issue more quickly. + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Environment overview (please complete the following information)** + - Environment location: [Bare-metal, Docker, Cloud(specify cloud provider)] + - Method of gQuant install: [Docker build, or from source] + + +**Environment details** +Please run and paste the output of the `/print_env.sh` script here, to gather any other relevant environment details + +**Additional context** +Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/documentation-request.md b/.github/ISSUE_TEMPLATE/documentation-request.md new file mode 100644 index 00000000..89a026f3 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/documentation-request.md @@ -0,0 +1,35 @@ +--- +name: Documentation request +about: Report incorrect or needed documentation +title: "[DOC]" +labels: "? - Needs Triage, doc" +assignees: '' + +--- + +## Report incorrect documentation + +**Location of incorrect documentation** +Provide links and line numbers if applicable. + +**Describe the problems or issues found in the documentation** +A clear and concise description of what you found to be incorrect. + +**Steps taken to verify documentation is incorrect** +List any steps you have taken: + +**Suggested fix for documentation** +Detail proposed changes to fix the documentation if you have any. + +--- + +## Report needed documentation + +**Report needed documentation** +A clear and concise description of what documentation you believe it is needed and why. + +**Describe the documentation you'd like** +A clear and concise description of what you want to happen. + +**Steps taken to search for needed documentation** +List any steps you have taken: diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 00000000..83a1dc60 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature request +about: Suggest an idea for gQuant +title: "[FEA]" +labels: "? - Needs Triage, feature request" +assignees: '' + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I wish I could use gQuant to do [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context, code examples, or references to existing implementations about the feature request here. diff --git a/.github/ISSUE_TEMPLATE/submit-question.md b/.github/ISSUE_TEMPLATE/submit-question.md new file mode 100644 index 00000000..4076ea9d --- /dev/null +++ b/.github/ISSUE_TEMPLATE/submit-question.md @@ -0,0 +1,10 @@ +--- +name: Submit question +about: Ask a general question about gQuant +title: "[QST]" +labels: "? - Needs Triage, question" +assignees: '' + +--- + +**What is your question?** diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 00000000..bafe6d23 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,49 @@ + diff --git a/README.md b/README.md index abe922dd..b2842c30 100644 --- a/README.md +++ b/README.md @@ -44,9 +44,8 @@ $ git clone https://github.com/rapidsai/gQuant.git - Build and run the container: ```bash -$ cd gQuant && . build.sh +$ cd gQuant/docker && . build.sh $ docker run --runtime=nvidia --rm -it -p 8888:8888 -p 8787:8787 -p 8786:8786 gquant/gquant:latest -$ source activate rapids $ bash rapids/notebooks/utils/start-jupyter.sh ``` diff --git a/build.sh b/build.sh deleted file mode 100644 index a51d120c..00000000 --- a/build.sh +++ /dev/null @@ -1,65 +0,0 @@ -D_FILE=${D_FILE:='Dockerfile.Rapids'} -D_CONT=${D_CONT:='gquant/gquant:latest'} - -cat > $D_FILE < $D_FILE <= 0: + port_mask_nan(asset_indicator.data.to_gpu_array(), out, 0, n - 1) + else: + port_mask_nan(asset_indicator.data.to_gpu_array(), out, n - 1, 0) + return cudf.Series(out) + + +def port_diff(asset_indicator, close_arr, n): + """ Calculate the port diff + + :param asset_indicator: the indicator of beginning of the stock + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps + :return: diff in cu.Series + """ + M = diff(close_arr.data.to_gpu_array(), n) + if n >= 0: + port_mask_nan(asset_indicator.data.to_gpu_array(), M, 0, n) + else: + port_mask_nan(asset_indicator.data.to_gpu_array(), M, n, 0) + return cudf.Series(M) + + +def port_shift(asset_indicator, close_arr, n): + """ Calculate the port diff + + :param asset_indicator: the indicator of beginning of the stock + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps + :return: shift in cu.Series + """ + M = shift(close_arr.data.to_gpu_array(), n) + if n >= 0: + port_mask_nan(asset_indicator.data.to_gpu_array(), M, 0, n) + else: + port_mask_nan(asset_indicator.data.to_gpu_array(), M, n, 0) + return cudf.Series(M) + + def bollinger_bands(close_arr, n): """Calculate the Bollinger Bands. See https://www.investopedia.com/terms/b/bollingerbands.asp for details @@ -89,6 +158,30 @@ def bollinger_bands(close_arr, n): return out(b1=cudf.Series(b1), b2=cudf.Series(b2)) +def port_bollinger_bands(asset_indicator, close_arr, n): + """Calculate the port Bollinger Bands. + See https://www.investopedia.com/terms/b/bollingerbands.asp for details + + :param asset_indicator: the indicator of beginning of the stock + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps + :return: b1 b2 + """ + MA = Rolling(n, close_arr).mean() + port_mask_nan(asset_indicator.data.to_gpu_array(), MA, 0, n - 1) + MSD = Rolling(n, close_arr).std() + port_mask_nan(asset_indicator.data.to_gpu_array(), MSD, 0, n - 1) + close_arr_gpu = numba.cuda.device_array_like(close_arr.data.to_gpu_array()) + close_arr_gpu[:] = close_arr.data.to_gpu_array()[:] + close_arr_gpu[0:n-1] = math.nan + MSD_4 = scale(MSD, 4.0) + b1 = division(MSD_4, MA) + b2 = division(summation(substract(close_arr_gpu, MA), scale(MSD, 2.0)), + MSD_4) + out = collections.namedtuple('Bollinger', 'b1 b2') + return out(b1=cudf.Series(b1), b2=cudf.Series(b2)) + + def trix(close_arr, n): """Calculate TRIX for given data. @@ -102,6 +195,20 @@ def trix(close_arr, n): return rate_of_change(cudf.Series(EX3), 2) +def port_trix(asset_indicator, close_arr, n): + """Calculate the port trix. + + :param asset_indicator: the indicator of beginning of the stock + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps + :return: expoential weighted moving average in cu.Series + """ + EX1 = PEwm(n, close_arr, asset_indicator).mean() + EX2 = PEwm(n, EX1, asset_indicator).mean() + EX3 = PEwm(n, EX2, asset_indicator).mean() + return rate_of_change(cudf.Series(EX3), 2) + + def macd(close_arr, n_fast, n_slow): """Calculate MACD, MACD Signal and MACD difference @@ -124,6 +231,7 @@ def macd(close_arr, n_fast, n_slow): def port_macd(asset_indicator, close_arr, n_fast, n_slow): """Calculate MACD, MACD Signal and MACD difference + :param asset_indicator: the indicator of beginning of the stock :param close_arr: close price of the bar, expect series from cudf :param n_fast: fast time steps :param n_slow: slow time steps @@ -156,6 +264,25 @@ def average_true_range(high_arr, low_arr, close_arr, n): return cudf.Series(ATR) +def port_average_true_range(asset_indicator, high_arr, + low_arr, close_arr, n): + """Calculate the port Average True Range + See https://www.investopedia.com/terms/a/atr.asp for details + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps + :return: average true range indicator + """ + tr = port_true_range(asset_indicator.data.to_gpu_array(), + high_arr.data.to_gpu_array(), + low_arr.data.to_gpu_array(), + close_arr.data.to_gpu_array()) + ATR = PEwm(n, tr, asset_indicator).mean() + return cudf.Series(ATR) + + def ppsr(high_arr, low_arr, close_arr): """Calculate Pivot Points, Supports and Resistances for given data @@ -184,6 +311,35 @@ def ppsr(high_arr, low_arr, close_arr): S3=cudf.Series(S3)) +def port_ppsr(asset_indicator, high_arr, low_arr, close_arr): + """Calculate port Pivot Points, Supports and Resistances for given data + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :return: PP R1 S1 R2 S2 R3 S3 + """ + high_gpu = high_arr.data.to_gpu_array() + low_gpu = low_arr.data.to_gpu_array() + close_gpu = close_arr.data.to_gpu_array() + PP = average_price(high_gpu, low_gpu, close_gpu) + R1 = substract(scale(PP, 2.0), low_gpu) + S1 = substract(scale(PP, 2.0), high_gpu) + R2 = substract(summation(PP, high_gpu), low_gpu) + S2 = summation(substract(PP, high_gpu), low_gpu) + R3 = summation(high_gpu, scale(substract(PP, low_gpu), 2.0)) + S3 = substract(low_gpu, scale(substract(high_gpu, PP), 2.0)) + out = collections.namedtuple('PPSR', 'PP R1 S1 R2 S2 R3 S3') + return out(PP=cudf.Series(PP), + R1=cudf.Series(R1), + S1=cudf.Series(S1), + R2=cudf.Series(R2), + S2=cudf.Series(S2), + R3=cudf.Series(R3), + S3=cudf.Series(S3)) + + def stochastic_oscillator_k(high_arr, low_arr, close_arr): """Calculate stochastic oscillator K for given data. @@ -196,6 +352,20 @@ def stochastic_oscillator_k(high_arr, low_arr, close_arr): return SOk +def port_stochastic_oscillator_k(asset_indicator, high_arr, + low_arr, close_arr): + """Calculate stochastic oscillator K for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :return: stochastic oscillator K in cudf.Series + """ + SOk = (close_arr - low_arr) / (high_arr - low_arr) + return SOk + + def stochastic_oscillator_d(high_arr, low_arr, close_arr, n): """Calculate stochastic oscillator D for given data. @@ -210,6 +380,22 @@ def stochastic_oscillator_d(high_arr, low_arr, close_arr, n): return cudf.Series(SOd) +def port_stochastic_oscillator_d(asset_indicator, high_arr, low_arr, + close_arr, n): + """Calculate port stochastic oscillator D for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps + :return: stochastic oscillator D in cudf.Series + """ + SOk = stochastic_oscillator_k(high_arr, low_arr, close_arr) + SOd = PEwm(n, SOk, asset_indicator).mean() + return cudf.Series(SOd) + + def average_directional_movement_index(high_arr, low_arr, close_arr, n, n_ADX): """Calculate the Average Directional Movement Index for given data. @@ -234,6 +420,34 @@ def average_directional_movement_index(high_arr, low_arr, close_arr, n, n_ADX): return ADX +def port_average_directional_movement_index(asset_indicator, + high_arr, low_arr, + close_arr, n, n_ADX): + """Calculate the port Average Directional Movement Index for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps to do EWM average + :param n_ADX: time steps to do EWM average of ADX + :return: Average Directional Movement Index in cudf.Series + """ + UpI, DoI = upDownMove(high_arr.data.to_gpu_array(), + low_arr.data.to_gpu_array()) + tr = port_true_range(asset_indicator.to_gpu_array(), + high_arr.data.to_gpu_array(), + low_arr.data.to_gpu_array(), + close_arr.data.to_gpu_array()) + ATR = PEwm(n, tr, asset_indicator).mean() + PosDI = division(PEwm(n, UpI, asset_indicator).mean(), ATR) + NegDI = division(PEwm(n, DoI, asset_indicator).mean(), ATR) + NORM = division(abs_arr(substract(PosDI, NegDI)), summation(PosDI, NegDI)) + port_mask_nan(asset_indicator.data.to_gpu_array(), NORM, -1, 0) + ADX = cudf.Series(PEwm(n_ADX, NORM, asset_indicator).mean()) + return ADX + + def vortex_indicator(high_arr, low_arr, close_arr, n): """Calculate the Vortex Indicator for given data. Vortex Indicator described here: @@ -256,6 +470,33 @@ def vortex_indicator(high_arr, low_arr, close_arr, n): return cudf.Series(VI) +def port_vortex_indicator(asset_indicator, high_arr, low_arr, close_arr, n): + """Calculate the port Vortex Indicator for given data. + Vortex Indicator described here: + + http://www.vortexindicator.com/VFX_VORTEX.PDF + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps to do EWM average + :return: Vortex Indicator in cudf.Series + """ + TR = port_true_range(asset_indicator.to_gpu_array(), + high_arr.data.to_gpu_array(), + low_arr.data.to_gpu_array(), + close_arr.data.to_gpu_array()) + + VM = port_lowhigh_diff(asset_indicator.to_gpu_array(), + high_arr.data.to_gpu_array(), + low_arr.data.to_gpu_array()) + + VI = division(Rolling(n, VM).sum(), Rolling(n, TR).sum()) + port_mask_nan(asset_indicator.data.to_gpu_array(), VI, 0, n - 1) + return cudf.Series(VI) + + def kst_oscillator(close_arr, r1, r2, r3, r4, n1, n2, n3, n4): """Calculate KST Oscillator for given data. @@ -286,6 +527,50 @@ def kst_oscillator(close_arr, r1, r2, r3, r4, n1, n2, n3, n4): return cudf.Series(KST) +def port_kst_oscillator(asset_indicator, close_arr, + r1, r2, r3, r4, n1, n2, n3, n4): + """Calculate port KST Oscillator for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param close_arr: close price of the bar, expect series from cudf + :param r1: r1 time steps + :param r2: r2 time steps + :param r3: r3 time steps + :param r4: r4 time steps + :param n1: n1 time steps + :param n2: n2 time steps + :param n3: n3 time steps + :param n4: n4 time steps + :return: KST Oscillator in cudf.Series + """ + M1 = diff(close_arr, r1 - 1) + N1 = shift(close_arr, r1 - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), M1, 0, r1 - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), N1, 0, r1 - 1) + M2 = diff(close_arr, r2 - 1) + N2 = shift(close_arr, r2 - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), M2, 0, r2 - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), N2, 0, r2 - 1) + M3 = diff(close_arr, r3 - 1) + N3 = shift(close_arr, r3 - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), M3, 0, r3 - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), N3, 0, r3 - 1) + M4 = diff(close_arr, r4 - 1) + N4 = shift(close_arr, r4 - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), M4, 0, r4 - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), N4, 0, r4 - 1) + term1 = Rolling(n1, division(M1, N1)).sum() + port_mask_nan(asset_indicator.data.to_gpu_array(), term1, 0, n1 - 1) + term2 = scale(Rolling(n2, division(M2, N2)).sum(), 2.0) + port_mask_nan(asset_indicator.data.to_gpu_array(), term2, 0, n2 - 1) + term3 = scale(Rolling(n3, division(M3, N3)).sum(), 3.0) + port_mask_nan(asset_indicator.data.to_gpu_array(), term3, 0, n3 - 1) + term4 = scale(Rolling(n4, division(M4, N4)).sum(), 4.0) + port_mask_nan(asset_indicator.data.to_gpu_array(), term4, 0, n4 - 1) + KST = summation(summation(summation(term1, term2), term3), term4) + return cudf.Series(KST) + + def relative_strength_index(high_arr, low_arr, n): """Calculate Relative Strength Index(RSI) for given data. @@ -309,6 +594,7 @@ def relative_strength_index(high_arr, low_arr, n): def port_relative_strength_index(asset_indicator, high_arr, low_arr, n): """Calculate Relative Strength Index(RSI) for given data. + :param asset_indicator: the indicator of beginning of the stock :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param n: time steps to do EWM average @@ -345,6 +631,25 @@ def mass_index(high_arr, low_arr, n1, n2): return cudf.Series(MassI) +def port_mass_index(asset_indicator, high_arr, low_arr, n1, n2): + """Calculate the port Mass Index for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param n1: n1 time steps + :param n1: n2 time steps + :return: Mass Index in cudf.Series + """ + Range = high_arr - low_arr + EX1 = PEwm(n1, Range, asset_indicator).mean() + EX2 = PEwm(n1, EX1, asset_indicator).mean() + Mass = division(EX1, EX2) + MassI = Rolling(n2, Mass).sum() + port_mask_nan(asset_indicator.data.to_gpu_array(), MassI, 0, n2 - 1) + return cudf.Series(MassI) + + def true_strength_index(close_arr, r, s): """Calculate True Strength Index (TSI) for given data. @@ -363,6 +668,26 @@ def true_strength_index(close_arr, r, s): return cudf.Series(TSI) +def port_true_strength_index(asset_indicator, close_arr, r, s): + """Calculate port True Strength Index (TSI) for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param close_arr: close price of the bar, expect series from cudf + :param r: r time steps + :param s: s time steps + :return: True Strength Index in cudf.Series + """ + M = diff(close_arr, 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), M, 0, 1) + aM = abs_arr(M) + EMA1 = PEwm(r, M, asset_indicator).mean() + aEMA1 = PEwm(r, aM, asset_indicator).mean() + EMA2 = PEwm(s, EMA1, asset_indicator).mean() + aEMA2 = PEwm(s, aEMA1, asset_indicator).mean() + TSI = division(EMA2, aEMA2) + return cudf.Series(TSI) + + def chaikin_oscillator(high_arr, low_arr, close_arr, volume_arr, n1, n2): """Calculate Chaikin Oscillator for given data. @@ -380,6 +705,27 @@ def chaikin_oscillator(high_arr, low_arr, close_arr, volume_arr, n1, n2): return Chaikin +def port_chaikin_oscillator(asset_indicator, high_arr, low_arr, + close_arr, volume_arr, n1, n2): + """Calculate port Chaikin Oscillator for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :param volume_arr: volume the bar, expect series from cudf + :param n1: n1 time steps + :param n2: n2 time steps + :return: Chaikin Oscillator indicator in cudf.Series + """ + ad = (2.0 * close_arr - high_arr - low_arr) / ( + high_arr - low_arr) * volume_arr + first = PEwm(n1, ad, asset_indicator).mean() + second = PEwm(n2, ad, asset_indicator).mean() + Chaikin = cudf.Series(substract(first, second)) + return Chaikin + + def money_flow_index(high_arr, low_arr, close_arr, volume_arr, n): """Calculate Money Flow Index and Ratio for given data. @@ -401,6 +747,31 @@ def money_flow_index(high_arr, low_arr, close_arr, volume_arr, n): return cudf.Series(MFI) +def port_money_flow_index(asset_indicator, high_arr, low_arr, + close_arr, volume_arr, n): + """Calculate port Money Flow Index and Ratio for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :param volume_arr: volume the bar, expect series from cudf + :param n: time steps + :return: Money Flow Index in cudf.Series + """ + PP = average_price(high_arr.data.to_gpu_array(), + low_arr.data.to_gpu_array(), + close_arr.data.to_gpu_array()) + + PosMF = port_money_flow(asset_indicator.data.to_gpu_array(), PP, + volume_arr.data.to_gpu_array()) + MFR = division(PosMF, + (multiply(PP, volume_arr.data.to_gpu_array()))) # TotMF + MFI = Rolling(n, MFR).mean() + port_mask_nan(asset_indicator.data.to_gpu_array(), MFI, 0, n - 1) + return cudf.Series(MFI) + + def on_balance_volume(close_arr, volume_arr, n): """Calculate On-Balance Volume for given data. @@ -415,6 +786,23 @@ def on_balance_volume(close_arr, volume_arr, n): return cudf.Series(OBV_ma) +def port_on_balance_volume(asset_indicator, close_arr, volume_arr, n): + """Calculate port On-Balance Volume for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param close_arr: close price of the bar, expect series from cudf + :param volume_arr: volume the bar, expect series from cudf + :param n: time steps + :return: On-Balance Volume in cudf.Series + """ + OBV = port_onbalance_volume(asset_indicator.data.to_gpu_array(), + close_arr.data.to_gpu_array(), + volume_arr.data.to_gpu_array()) + OBV_ma = Rolling(n, OBV).mean() + port_mask_nan(asset_indicator.data.to_gpu_array(), OBV_ma, 0, n - 1) + return cudf.Series(OBV_ma) + + def force_index(close_arr, volume_arr, n): """Calculate Force Index for given data. @@ -427,6 +815,20 @@ def force_index(close_arr, volume_arr, n): return cudf.Series(F) +def port_force_index(asset_indicator, close_arr, volume_arr, n): + """Calculate port Force Index for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param close_arr: close price of the bar, expect series from cudf + :param volume_arr: volume the bar, expect series from cudf + :param n: time steps + :return: Force Index in cudf.Series + """ + F = multiply(diff(close_arr, n), diff(volume_arr, n)) + port_mask_nan(asset_indicator.data.to_gpu_array(), F, 0, n) + return cudf.Series(F) + + def ease_of_movement(high_arr, low_arr, volume_arr, n): """Calculate Ease of Movement for given data. @@ -447,6 +849,29 @@ def ease_of_movement(high_arr, low_arr, volume_arr, n): return cudf.Series(Eom_ma) +def port_ease_of_movement(asset_indicator, high_arr, low_arr, volume_arr, n): + """Calculate port Ease of Movement for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param volume_arr: volume the bar, expect series from cudf + :param n: time steps + :return: Ease of Movement in cudf.Series + """ + high_arr_gpu = high_arr.data.to_gpu_array() + low_arr_gpu = low_arr.data.to_gpu_array() + + EoM = division(multiply(summation(diff(high_arr_gpu, 1), + diff(low_arr_gpu, 1)), + substract(high_arr_gpu, low_arr_gpu)), + scale(volume_arr.data.to_gpu_array(), 2.0)) + port_mask_nan(asset_indicator.data.to_gpu_array(), EoM, 0, 1) + Eom_ma = Rolling(n, EoM).mean() + port_mask_nan(asset_indicator.data.to_gpu_array(), Eom_ma, 0, n - 1) + return cudf.Series(Eom_ma) + + def ultimate_oscillator(high_arr, low_arr, close_arr): """Calculate Ultimate Oscillator for given data. @@ -467,6 +892,31 @@ def ultimate_oscillator(high_arr, low_arr, close_arr): return cudf.Series(UltO) +def port_ultimate_oscillator(asset_indicator, high_arr, low_arr, close_arr): + """Calculate port Ultimate Oscillator for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :return: Ultimate Oscillator in cudf.Series + """ + TR_l, BP_l = port_ultimate_osc(asset_indicator.data.to_gpu_array(), + high_arr.data.to_gpu_array(), + low_arr.data.to_gpu_array(), + close_arr.data.to_gpu_array()) + term1 = division(scale(Rolling(7, BP_l).sum(), 4.0), + Rolling(7, TR_l).sum()) + term2 = division(scale(Rolling(14, BP_l).sum(), 2.0), + Rolling(14, TR_l).sum()) + term3 = division(Rolling(28, BP_l).sum(), Rolling(28, TR_l).sum()) + port_mask_nan(asset_indicator.data.to_gpu_array(), term1, 0, 6) + port_mask_nan(asset_indicator.data.to_gpu_array(), term2, 0, 13) + port_mask_nan(asset_indicator.data.to_gpu_array(), term3, 0, 27) + UltO = summation(summation(term1, term2), term3) + return cudf.Series(UltO) + + def donchian_channel(high_arr, low_arr, n): """Calculate donchian channel of given pandas data frame. @@ -483,6 +933,27 @@ def donchian_channel(high_arr, low_arr, n): return cudf.Series(donchian_chan) +def port_donchian_channel(asset_indicator, high_arr, low_arr, n): + """Calculate port donchian channel of given pandas data frame. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param n: time steps + :return: donchian channel in cudf.Series + """ + max_high = Rolling(n, high_arr).max() + port_mask_nan(asset_indicator.data.to_gpu_array(), max_high, 0, n - 1) + min_low = Rolling(n, low_arr).min() + port_mask_nan(asset_indicator.data.to_gpu_array(), min_low, 0, n - 1) + dc_l = substract(max_high, min_low) + # dc_l[:n-1] = 0.0 + port_mask_zero(asset_indicator.data.to_gpu_array(), dc_l, 0, n - 1) + donchian_chan = shift(dc_l, n - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), donchian_chan, 0, n - 1) + return cudf.Series(donchian_chan) + + def keltner_channel(high_arr, low_arr, close_arr, n): """Calculate Keltner Channel for given data. @@ -502,6 +973,31 @@ def keltner_channel(high_arr, low_arr, close_arr, n): return out(KelChM=KelChM, KelChU=KelChU, KelChD=KelChD) +def port_keltner_channel(asset_indicator, high_arr, low_arr, close_arr, n): + """Calculate port Keltner Channel for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps + :return: Keltner Channel in cudf.Series + """ + M = ((high_arr + low_arr + close_arr) / 3.0) + KelChM = Rolling(n, M).mean() + port_mask_nan(asset_indicator.data.to_gpu_array(), KelChM, 0, n - 1) + U = ((4.0 * high_arr - 2.0 * low_arr + close_arr) / 3.0) + KelChU = Rolling(n, U).mean() + port_mask_nan(asset_indicator.data.to_gpu_array(), KelChU, 0, n - 1) + D = ((-2.0 * high_arr + 4.0 * low_arr + close_arr) / 3.0) + KelChD = Rolling(n, D).mean() + port_mask_nan(asset_indicator.data.to_gpu_array(), KelChD, 0, n - 1) + out = collections.namedtuple('Keltner', 'KelChM KelChU KelChD') + return out(KelChM=cudf.Series(KelChM), + KelChU=cudf.Series(KelChU), + KelChD=cudf.Series(KelChD)) + + def coppock_curve(close_arr, n): """Calculate Coppock Curve for given data. @@ -519,6 +1015,32 @@ def coppock_curve(close_arr, n): return cudf.Series(Copp) +def port_coppock_curve(asset_indicator, close_arr, n): + """Calculate port Coppock Curve for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps + :return: Coppock Curve in cudf.Series + """ + M = diff(close_arr, int(n * 11 / 10) - 1) + N = shift(close_arr, int(n * 11 / 10) - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), M, 0, + int(n * 11 / 10) - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), N, 0, + int(n * 11 / 10) - 1) + ROC1 = division(M, N) + M = diff(close_arr, int(n * 14 / 10) - 1) + N = shift(close_arr, int(n * 14 / 10) - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), M, 0, + int(n * 14 / 10) - 1) + port_mask_nan(asset_indicator.data.to_gpu_array(), N, 0, + int(n * 14 / 10) - 1) + ROC2 = division(M, N) + Copp = PEwm(n, summation(ROC1, ROC2), asset_indicator).mean() + return cudf.Series(Copp) + + def accumulation_distribution(high_arr, low_arr, close_arr, vol_arr, n): """Calculate Accumulation/Distribution for given data. @@ -535,6 +1057,26 @@ def accumulation_distribution(high_arr, low_arr, close_arr, vol_arr, n): return cudf.Series(division(M, N)) +def port_accumulation_distribution(asset_indicator, high_arr, + low_arr, close_arr, vol_arr, n): + """Calculate port Accumulation/Distribution for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :param vol_arr: volume of the bar, expect series from cudf + :param n: time steps + :return: Accumulation/Distribution in cudf.Series + """ + ad = (2.0 * close_arr - high_arr - low_arr)/(high_arr - low_arr) * vol_arr + M = diff(ad, n-1) + port_mask_nan(asset_indicator.data.to_gpu_array(), M, 0, n - 1) + N = shift(ad, n-1) + port_mask_nan(asset_indicator.data.to_gpu_array(), N, 0, n - 1) + return cudf.Series(division(M, N)) + + def commodity_channel_index(high_arr, low_arr, close_arr, n): """Calculate Commodity Channel Index for given data. @@ -551,3 +1093,25 @@ def commodity_channel_index(high_arr, low_arr, close_arr, n): N = Rolling(n, PP).std() CCI = division(substract(PP, M), N) return cudf.Series(CCI) + + +def port_commodity_channel_index(asset_indicator, high_arr, + low_arr, close_arr, n): + """Calculate port Commodity Channel Index for given data. + + :param asset_indicator: the indicator of beginning of the stock + :param high_arr: high price of the bar, expect series from cudf + :param low_arr: low price of the bar, expect series from cudf + :param close_arr: close price of the bar, expect series from cudf + :param n: time steps + :return: Commodity Channel Index in cudf.Series + """ + PP = average_price(high_arr.data.to_gpu_array(), + low_arr.data.to_gpu_array(), + close_arr.data.to_gpu_array()) + M = Rolling(n, PP).mean() + port_mask_nan(asset_indicator.data.to_gpu_array(), M, 0, n - 1) + N = Rolling(n, PP).std() + port_mask_nan(asset_indicator.data.to_gpu_array(), N, 0, n - 1) + CCI = division(substract(PP, M), N) + return cudf.Series(CCI) diff --git a/gquant/cuindicator/util.py b/gquant/cuindicator/util.py index c8a63579..513cee50 100755 --- a/gquant/cuindicator/util.py +++ b/gquant/cuindicator/util.py @@ -41,6 +41,23 @@ def ultimate_oscillator_kernel(high_arr, low_arr, close_arr, TR_arr, BP_arr, BP_arr[i] = BP +@cuda.jit +def port_ultimate_oscillator_kernel(asset_ind, high_arr, low_arr, close_arr, + TR_arr, BP_arr, + arr_len): + i = cuda.grid(1) + if i < arr_len: + if asset_ind[i] == 1: + TR_arr[i] = 0 + BP_arr[i] = 0 + else: + TR = (max(high_arr[i], + close_arr[i - 1]) - min(low_arr[i], close_arr[i - 1])) + TR_arr[i] = TR + BP = close_arr[i] - min(low_arr[i], close_arr[i - 1]) + BP_arr[i] = BP + + @cuda.jit def moneyflow_kernel(pp_arr, volume_arr, out_arr, arr_len): i = cuda.grid(1) @@ -54,6 +71,19 @@ def moneyflow_kernel(pp_arr, volume_arr, out_arr, arr_len): out_arr[i] = 0.0 +@cuda.jit +def port_moneyflow_kernel(asset_ind, pp_arr, volume_arr, out_arr, arr_len): + i = cuda.grid(1) + if i < arr_len: + if asset_ind[i] == 1: + out_arr[i] = 0 + else: + if pp_arr[i] > pp_arr[i - 1]: + out_arr[i] = pp_arr[i] * volume_arr[i] + else: + out_arr[i] = 0.0 + + @cuda.jit def onbalance_kernel(close_arr, volume_arr, out_arr, arr_len): i = cuda.grid(1) @@ -70,6 +100,21 @@ def onbalance_kernel(close_arr, volume_arr, out_arr, arr_len): out_arr[i] = -volume_arr[i] +@cuda.jit +def port_onbalance_kernel(asset_ind, close_arr, volume_arr, out_arr, arr_len): + i = cuda.grid(1) + if i < arr_len: + if asset_ind[i] == 1: + out_arr[i] = 0 + else: + if close_arr[i] - close_arr[i - 1] > 0: + out_arr[i] = volume_arr[i] + elif close_arr[i] - close_arr[i - 1] == 0: + out_arr[i] = 0.0 + else: + out_arr[i] = -volume_arr[i] + + @cuda.jit def average_price_kernel(high_arr, low_arr, close_arr, out_arr, arr_len): i = cuda.grid(1) @@ -89,6 +134,51 @@ def true_range_kernel(high_arr, low_arr, close_arr, out_arr, arr_len): close_arr[i - 1]) +@cuda.jit +def port_true_range_kernel(asset_ind, high_arr, low_arr, close_arr, out_arr, + arr_len): + i = cuda.grid(1) + if i < arr_len: + if asset_ind[i] == 1: + out_arr[i] = 0 + else: + out_arr[i] = max(high_arr[i], + close_arr[i - 1]) - min(low_arr[i], + close_arr[i - 1]) + + +@cuda.jit +def port_mask_kernel(asset_ind, beg, end, out_arr, arr_len): + i = cuda.grid(1) + if i < arr_len: + if asset_ind[i] == 1: + if beg + i >= 0: + for j in range(beg + i, min(end + i, arr_len)): + out_arr[j] = math.nan + else: + for j in range(beg + i + arr_len, min(end + i + arr_len, + arr_len)): + out_arr[j] = math.nan + for j in range(0, min(end + i, arr_len)): + out_arr[j] = math.nan + + +@cuda.jit +def port_mask_zero_kernel(asset_ind, beg, end, out_arr, arr_len): + i = cuda.grid(1) + if i < arr_len: + if asset_ind[i] == 1: + if beg + i >= 0: + for j in range(beg + i, min(end + i, arr_len)): + out_arr[j] = 0 + else: + for j in range(beg + i + arr_len, min(end + i + arr_len, + arr_len)): + out_arr[j] = 0 + for j in range(0, min(end + i, arr_len)): + out_arr[j] = 0 + + @cuda.jit def lowhigh_diff_kernel(high_arr, low_arr, out_arr, arr_len): i = cuda.grid(1) @@ -100,6 +190,17 @@ def lowhigh_diff_kernel(high_arr, low_arr, out_arr, arr_len): abs(low_arr[i] - high_arr[i - 1]) +@cuda.jit +def port_lowhigh_diff_kernel(asset_ind, high_arr, low_arr, out_arr, arr_len): + i = cuda.grid(1) + if i < arr_len: + if asset_ind[i] == 1: + out_arr[i] = 0 + else: + out_arr[i] = abs(high_arr[i] - low_arr[i - 1]) - \ + abs(low_arr[i] - high_arr[i - 1]) + + @cuda.jit def up_down_kernel(high_arr, low_arr, upD_arr, doD_arr, arr_len): i = cuda.grid(1) @@ -221,6 +322,23 @@ def ultimate_osc(high_arr, low_arr, close_arr): return TR_arr, BP_arr +def port_ultimate_osc(asset_ind, high_arr, low_arr, close_arr): + TR_arr = cuda.device_array_like(high_arr) + BP_arr = cuda.device_array_like(high_arr) + array_len = len(high_arr) + number_of_blocks = (array_len + ( + number_of_threads - 1)) // number_of_threads + port_ultimate_oscillator_kernel[(number_of_blocks,), + (number_of_threads,)](asset_ind, + high_arr, + low_arr, + close_arr, + TR_arr, + BP_arr, + array_len) + return TR_arr, BP_arr + + def abs_arr(in_arr): out_arr = cuda.device_array_like(in_arr) array_len = len(in_arr) @@ -245,6 +363,45 @@ def true_range(high_arr, low_arr, close_arr): return out_arr +def port_true_range(asset_indicator, high_arr, low_arr, close_arr): + out_arr = cuda.device_array_like(high_arr) + array_len = len(high_arr) + number_of_blocks = (array_len + ( + number_of_threads - 1)) // number_of_threads + port_true_range_kernel[(number_of_blocks,), + (number_of_threads,)](asset_indicator, + high_arr, + low_arr, + close_arr, + out_arr, + array_len) + return out_arr + + +def port_mask_nan(asset_indicator, input_arr, beg, end): + array_len = len(input_arr) + number_of_blocks = (array_len + ( + number_of_threads - 1)) // number_of_threads + port_mask_kernel[(number_of_blocks,), + (number_of_threads,)](asset_indicator, + beg, + end, + input_arr, + array_len) + + +def port_mask_zero(asset_indicator, input_arr, beg, end): + array_len = len(input_arr) + number_of_blocks = (array_len + ( + number_of_threads - 1)) // number_of_threads + port_mask_zero_kernel[(number_of_blocks,), + (number_of_threads,)](asset_indicator, + beg, + end, + input_arr, + array_len) + + def average_price(high_arr, low_arr, close_arr): out_arr = cuda.device_array_like(high_arr) array_len = len(high_arr) @@ -270,6 +427,20 @@ def money_flow(pp_arr, volume_arr): return out_arr +def port_money_flow(asset_ind, pp_arr, volume_arr): + out_arr = cuda.device_array_like(pp_arr) + array_len = len(pp_arr) + number_of_blocks = (array_len + ( + number_of_threads - 1)) // number_of_threads + port_moneyflow_kernel[(number_of_blocks,), + (number_of_threads,)](asset_ind, + pp_arr, + volume_arr, + out_arr, + array_len) + return out_arr + + def onbalance_volume(close_arr, volume_arr): out_arr = cuda.device_array_like(close_arr) array_len = len(close_arr) @@ -282,6 +453,20 @@ def onbalance_volume(close_arr, volume_arr): return out_arr +def port_onbalance_volume(asset_ind, close_arr, volume_arr): + out_arr = cuda.device_array_like(close_arr) + array_len = len(close_arr) + number_of_blocks = (array_len + ( + number_of_threads - 1)) // number_of_threads + port_onbalance_kernel[(number_of_blocks,), + (number_of_threads,)](asset_ind, + close_arr, + volume_arr, + out_arr, + array_len) + return out_arr + + def lowhigh_diff(high_arr, low_arr): out_arr = cuda.device_array_like(high_arr) array_len = len(high_arr) @@ -294,6 +479,20 @@ def lowhigh_diff(high_arr, low_arr): return out_arr +def port_lowhigh_diff(asset_ind, high_arr, low_arr): + out_arr = cuda.device_array_like(high_arr) + array_len = len(high_arr) + number_of_blocks = \ + (array_len + (number_of_threads - 1)) // number_of_threads + port_lowhigh_diff_kernel[(number_of_blocks,), + (number_of_threads,)](asset_ind, + high_arr, + low_arr, + out_arr, + array_len) + return out_arr + + def substract(in_arr1, in_arr2): out_arr = cuda.device_array_like(in_arr1) array_len = len(in_arr1) diff --git a/gquant/dataframe_flow/__init__.py b/gquant/dataframe_flow/__init__.py index 23935e9d..5986b923 100644 --- a/gquant/dataframe_flow/__init__.py +++ b/gquant/dataframe_flow/__init__.py @@ -1,2 +1,3 @@ from .node import * # noqa: F401,F403 -from .workflow import * # noqa: F401,F403 +from .taskSpecSchema import * # noqa: F401,F403 +from .taskGraph import * # noqa: F401,F403 diff --git a/gquant/dataframe_flow/node.py b/gquant/dataframe_flow/node.py index 61a96896..ba64734b 100644 --- a/gquant/dataframe_flow/node.py +++ b/gquant/dataframe_flow/node.py @@ -6,42 +6,26 @@ import dask_cudf import dask +OUTPUT_ID = 'f291b900-bd19-11e9-aca3-a81e84f29b0f_uni_output' -__all__ = ['Node', 'TaskSpecSchema'] - - -class TaskSpecSchema(object): - '''Outline fields expected in a dictionary specifying a task node. - - :ivar id: unique id or name for the node - :ivar plugin_type: Plugin class i.e. subclass of Node. Specified as string - or subclass of Node - :ivar conf: Configuration for the plugin i.e. parameterization. This is a - dictionary. - :ivar modulepath: Path to python module for custom plugin types. - :ivar inputs: List of ids of other tasks or an empty list. - ''' - - uid = 'id' - plugin_type = 'type' - conf = 'conf' - modulepath = 'filepath' - inputs = 'inputs' - - # load = 'load' - # save = 'save' +__all__ = ['Node', 'OUTPUT_ID'] class Node(object): __metaclass__ = abc.ABCMeta - cache_dir = ".cache" - - def __init__(self, uid, conf, load=False, save=False): - self.uid = uid - self.conf = conf - self.load = load - self.save = save + cache_dir = os.getenv('GQUANT_CACHE_DIR', ".cache") + + def __init__(self, task): + from .taskSpecSchema import TaskSpecSchema + from .task import Task + # make sure is is a task object + assert isinstance(task, Task) + self._task_obj = task # save the task obj + self.uid = task[TaskSpecSchema.task_id] + self.conf = task[TaskSpecSchema.conf] + self.load = task.get(TaskSpecSchema.load, False) + self.save = task.get(TaskSpecSchema.save, False) self.inputs = [] self.outputs = [] self.visited = False @@ -177,6 +161,7 @@ def __valide(self, input_df, ref): if not isinstance(input_df, cudf.DataFrame) and \ not isinstance(input_df, dask_cudf.DataFrame): return True + i_cols = input_df.columns if len(i_cols) != len(ref): print("expect %d columns, only see %d columns" @@ -184,22 +169,41 @@ def __valide(self, input_df, ref): print("ref:", ref) print("columns", i_cols) raise Exception("not valid for node %s" % (self.uid)) + for col in ref.keys(): if col not in i_cols: print("error for node %s, %s is not in the required input df" % (self.uid, col)) return False + if ref[col] is None: continue + + err_msg = "for node {} type {}, column {} type {} "\ + "does not match expected type {}".format( + self.uid, type(self), col, input_df[col].dtype, + ref[col]) + if ref[col] == 'category': - d_type = pd.core.dtypes.dtypes.CategoricalDtype() + # comparing pandas.core.dtypes.dtypes.CategoricalDtype to + # numpy.dtype causes TypeError. Instead, let's compare + # after converting all types to their string representation + # d_type_tuple = (pd.core.dtypes.dtypes.CategoricalDtype(),) + d_type_tuple = (str(pd.core.dtypes.dtypes.CategoricalDtype()),) + elif ref[col] == 'date': + # Cudf read_csv doesn't understand 'datetime64[ms]' even + # though it reads the data in as 'datetime64[ms]', but + # expects 'date' as dtype specified passed to read_csv. + d_type_tuple = ('datetime64[ms]', 'date',) else: - d_type = np.dtype(ref[col]) - if (input_df[col].dtype != d_type): - print("error for node %s, column %s type %s " - "does not match type %s" - % (self.uid, col, input_df[col].dtype, ref[col])) + d_type_tuple = (str(np.dtype(ref[col])),) + + if (str(input_df[col].dtype) not in d_type_tuple): + print("ERROR: {}".format(err_msg)) + # Maybe raise an exception here and have the caller + # try/except the validation routine. return False + return True def __input_ready(self): @@ -302,7 +306,7 @@ def __call__(self, inputs): else: output_df = self.process(inputs) - if self.uid != 'unique_output' and output_df is None: + if self.uid != OUTPUT_ID and output_df is None: raise Exception("None output") elif (isinstance(output_df, cudf.DataFrame) or isinstance(output_df, dask_cudf.DataFrame) diff --git a/gquant/dataframe_flow/task.py b/gquant/dataframe_flow/task.py new file mode 100644 index 00000000..3111aee7 --- /dev/null +++ b/gquant/dataframe_flow/task.py @@ -0,0 +1,81 @@ +import importlib +import copy +from .node import Node +from .taskSpecSchema import TaskSpecSchema +import os + +__all__ = ['Task'] + +DEFAULT_MODULE = os.getenv('GQUANT_PLUGIN_MODULE', "gquant.plugin_nodes") +MODLIB = importlib.import_module(DEFAULT_MODULE) + + +class Task(object): + ''' A strong typed Task class that is converted from dictionary. + ''' + + def __init__(self, task_spec): + + self._task_spec = {} # internal dict + + # whatever is passed in has to be valid + TaskSpecSchema.validate(task_spec) + self._task_spec = copy.copy(task_spec) + # deepcopies of inputs can still be done + self._task_spec[TaskSpecSchema.inputs] = \ + copy.deepcopy(task_spec[TaskSpecSchema.inputs]) + + def __getitem__(self, key): + return self._task_spec[key] + + def get(self, key, default=None): + return self._task_spec.get(key, default) + + def get_node_obj(self, replace=None): + """ + instantiate a node instance for this task given the replacement setup + + Arguments + ------- + replace: dict + conf parameters replacement + + Returns + ----- + object + Node instance + """ + task_spec = copy.copy(self._task_spec) + task_spec.update(replace) + + node_id = task_spec[TaskSpecSchema.task_id] + modulepath = task_spec.get(TaskSpecSchema.filepath) + + node_type = task_spec[TaskSpecSchema.node_type] + task = Task(task_spec) + + if isinstance(node_type, str): + if modulepath is not None: + spec = importlib.util.spec_from_file_location(node_id, + modulepath) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + NodeClass = getattr(mod, node_type) + else: + global MODLIB + NodeClass = getattr(MODLIB, node_type) + elif issubclass(node_type, Node): + NodeClass = node_type + else: + raise "Not supported" + + node = NodeClass(task) + return node + + +if __name__ == "__main__": + t = {'id': 'test', + 'type': "DropNode", + 'conf': {}, + 'inputs': ["node_other"]} + task = Task(t) diff --git a/gquant/dataframe_flow/taskGraph.py b/gquant/dataframe_flow/taskGraph.py new file mode 100644 index 00000000..56e489a3 --- /dev/null +++ b/gquant/dataframe_flow/taskGraph.py @@ -0,0 +1,261 @@ +from collections import OrderedDict +import networkx as nx +import yaml +from .node import Node, OUTPUT_ID +from .task import Task +from .taskSpecSchema import TaskSpecSchema +import warnings + + +__all__ = ['TaskGraph'] + + +class TaskGraph(object): + ''' TaskGraph class that is used to store the graph. + ''' + + __SETUP_YAML_ONCE = False + + @staticmethod + def setup_yaml(): + '''Write out yaml in order for OrderedDict.''' + # https://stackoverflow.com/a/8661021 + # https://stackoverflow.com/questions/47692094/lambda-works- + # defined-function-does-not # noqa + # represent_dict_order = lambda dumper, data: \ + # dumper.represent_mapping('tag:yaml.org,2002:map', data.items()) + def represent_dict_order(dumper, data): + return dumper.represent_mapping('tag:yaml.org,2002:map', + data.items()) + yaml.add_representer(OrderedDict, represent_dict_order) + + TaskGraph.__SETUP_YAML_ONCE = True + + def __init__(self, task_spec_list=None): + ''' + :param task_spec_list: List of task-spec dicts per TaskSpecSchema. + ''' + self.__task_list = [] + self.__index = 0 + if task_spec_list is not None: + for task_spec in task_spec_list: + self.__task_list.append(Task(task_spec)) + + def __len__(self): + return len(self.__task_list) + + def __iter__(self): + self.__index = 0 + return self + + def __next__(self): + if self.__index == len(self.__task_list): + raise StopIteration + obj = self.__task_list[self.__index] + self.__index += 1 + return obj + + def __find_roots(self, node, inputs, consider_load=True): + """ + find the root nodes that the `node` dependes on + + Arguments + ------- + node: Node + the leaf node, of whom we need to find the dependent input nodes + inputs: list + resulting list to store all the root nodes in this list + consider_load: bool + whether it skips the node which are loading cache file or not + Returns + ----- + None + + """ + + if (node.visited): + return + node.visited = True + if len(node.inputs) == 0: + inputs.append(node) + return + if consider_load and node.load: + inputs.append(node) + return + for i in node.inputs: + self.__find_roots(i, inputs, consider_load) + + @staticmethod + def load_taskgraph(filename): + """ + load the yaml file to TaskGraph object + + Arguments + ------- + filename: str + the filename pointing to the yaml file in the filesystem + Returns + ----- + object + the TaskGraph instance + + """ + + with open(filename) as f: + obj = yaml.safe_load(f) + t = TaskGraph(obj) + return t + + def save_taskgraph(self, filename): + """ + Write a list of tasks i.e. taskgraph to a yaml file. + + Arguments + ------- + filename: str + The filename to write a yaml file to. + + """ + + if not TaskGraph.__SETUP_YAML_ONCE: + TaskGraph.setup_yaml() + + # we want -id to be first in the resulting yaml file. + tlist_od = [] # task list ordered + for task in self.__task_list: + tod = OrderedDict([(TaskSpecSchema.task_id, 'idholder'), + (TaskSpecSchema.node_type, 'typeholder'), + (TaskSpecSchema.conf, 'confholder'), + (TaskSpecSchema.inputs, 'inputsholder') + ]) + tod.update(task._task_spec) + tlist_od.append(tod) + + with open(filename, 'w') as fh: + yaml.dump(tlist_od, fh, default_flow_style=False) + + def viz_graph(self): + """ + Generate the visulization of the graph in the JupyterLab + + Returns + ----- + nx.DiGraph + """ + G = nx.DiGraph() + # instantiate objects + for o in self.__task_list: + for i in o[TaskSpecSchema.inputs]: + G.add_edge(i, o[TaskSpecSchema.task_id]) + return G + + def build(self, replace=None): + """ + compute the graph structure of the nodes. It will set the input and + output nodes for each of the node + + Arguments + ------- + replace: dict + conf parameters replacement + """ + self.__node_dict = {} + replace = dict() if replace is None else replace + + # check if there are item in the replace that is not in the graph + task_ids = set([task[TaskSpecSchema.task_id] for task in self]) + for rkey in replace.keys(): + if rkey not in task_ids: + warnings.warn( + 'Replace task-id {} not found in task-graph'.format(rkey), + RuntimeWarning) + + # instantiate objects + task_id = TaskSpecSchema.task_id + for task in self.__task_list: + node = task.get_node_obj(replace.get(task[task_id], {})) + self.__node_dict[task[task_id]] = node + + # build the graph + for task_id in self.__node_dict: + node = self.__node_dict[task_id] + for input_id in node._task_obj[TaskSpecSchema.inputs]: + input_node = self.__node_dict[input_id] + node.inputs.append(input_node) + input_node.outputs.append(node) + + # this part is to do static type checks + raw_inputs = [] + for k in self.__node_dict.keys(): + self.__find_roots(self.__node_dict[k], raw_inputs, + consider_load=False) + + for i in raw_inputs: + i.columns_flow() + + # clean up the visited status for run computations + for task_id in self.__node_dict: + self.__node_dict[task_id].visited = False + + def __getitem__(self, key): + return self.__node_dict[key] + + def __str__(self): + out_str = "" + for k in self.__node_dict.keys(): + out_str += k + ": " + str(self.__node_dict[k]) + "\n" + return out_str + + def run(self, outputs, replace=None): + """ + Flow the dataframes in the graph to do the data science computations. + + Arguments + ------- + outputs: list + a list of the leaf node IDs for which to return the final results + replace: list + a dict that defines the conf parameters replacement + + Returns + ----- + tuple + the results corresponding to the outputs list + """ + replace = dict() if replace is None else replace + self.build(replace) + output_task = Task({TaskSpecSchema.task_id: OUTPUT_ID, + TaskSpecSchema.conf: {}, + TaskSpecSchema.node_type: "dumpy", + TaskSpecSchema.inputs: []}) + output_node = Node(output_task) + # want to save the intermediate results + output_node.clear_input = False + results = [] + results_obj = [] + for o in outputs: + o_obj = self.__node_dict[o] + results_obj.append(o_obj) + output_node.inputs.append(o_obj) + o_obj.outputs.append(output_node) + + inputs = [] + self.__find_roots(output_node, inputs, consider_load=True) + # now clean up the graph, removed the node that is not used for + # computation + for key in self.__node_dict: + current_obj = self.__node_dict[key] + if not current_obj.visited: + for i in current_obj.inputs: + i.outputs.remove(current_obj) + current_obj.inputs = [] + + for i in inputs: + i.flow() + + for r_obj in results_obj: + results.append(output_node.input_df[r_obj]) + + # clean the results afterwards + output_node.input_df = {} + return tuple(results) diff --git a/gquant/dataframe_flow/taskSpecSchema.py b/gquant/dataframe_flow/taskSpecSchema.py new file mode 100644 index 00000000..e05238b5 --- /dev/null +++ b/gquant/dataframe_flow/taskSpecSchema.py @@ -0,0 +1,60 @@ +from .node import Node + + +__all__ = ['TaskSpecSchema'] + + +class TaskSpecSchema(object): + '''Outline fields expected in a dictionary specifying a task node. + :cvar task_id: unique id or name for the node + :cvar node_type: Plugin class i.e. subclass of Node. Specified as string + or subclass of Node + :cvar conf: Configuration for the plugin i.e. parameterization. This is a + dictionary. + :cvar filepath: Path to python module for custom plugin types. + :cvar inputs: List of ids of other tasks or an empty list. + ''' + + task_id = 'id' + node_type = 'type' + conf = 'conf' + filepath = 'filepath' + inputs = 'inputs' + load = 'load' + save = 'save' + + @classmethod + def _typecheck(cls, schema_field, value): + if (schema_field == cls.task_id): + assert isinstance(value, str) + elif schema_field == cls.node_type: + assert (isinstance(value, str) or issubclass(value, Node)) + elif schema_field == cls.conf: + assert (isinstance(value, dict) or isinstance(value, list)) + elif schema_field == cls.filepath: + assert isinstance(value, str) + elif schema_field == cls.inputs: + assert isinstance(value, list) + for item in value: + assert isinstance(item, str) + elif schema_field == cls.load: + pass + elif schema_field == cls.save: + assert isinstance(value, bool) + else: + raise KeyError + + _schema_req_fields = [task_id, node_type, conf, inputs] + + @classmethod + def validate(cls, task_spec): + ''' + :param task_spec: A dictionary per TaskSpecSchema + ''' + for ifield in cls._schema_req_fields: + if ifield not in task_spec: + raise KeyError('task spec missing required field: {}' + .format(ifield)) + + for task_field, field_val in task_spec.items(): + cls._typecheck(task_field, field_val) diff --git a/gquant/dataframe_flow/workflow.py b/gquant/dataframe_flow/workflow.py deleted file mode 100644 index 7d6d2846..00000000 --- a/gquant/dataframe_flow/workflow.py +++ /dev/null @@ -1,259 +0,0 @@ -from collections import OrderedDict -import yaml -import copy -import networkx as nx -import importlib - -from .node import Node - -__all__ = ['run', 'save_workflow', 'load_workflow', 'viz_graph', 'build_workflow'] - - -DEFAULT_MODULE = "gquant.plugin_nodes" -mod_lib = importlib.import_module(DEFAULT_MODULE) - -__SETUP_YAML_ONCE = False - - -def setup_yaml(): - '''Write out yaml in order for OrderedDict.''' - # https://stackoverflow.com/a/8661021 - # https://stackoverflow.com/questions/47692094/lambda-works-defined-function-does-not # noqa - # represent_dict_order = lambda dumper, data: \ - # dumper.represent_mapping('tag:yaml.org,2002:map', data.items()) - def represent_dict_order(dumper, data): - return dumper.represent_mapping('tag:yaml.org,2002:map', data.items()) - yaml.add_representer(OrderedDict, represent_dict_order) - - global __SETUP_YAML_ONCE - __SETUP_YAML_ONCE = True - - -def save_workflow(task_list, filename): - """ - Write a list of tasks i.e. workflow to a yaml file. - - Arguments - ------- - task_list: list - List of dictionary objects describing tasks. - filename: str - The filename to write a yaml file to. - - """ - - global __SETUP_YAML_ONCE - if not __SETUP_YAML_ONCE: - setup_yaml() - - # we want -id to be first in the resulting yaml file. - tlist_od = [] # task list ordered - for task in task_list: - tod = OrderedDict([('id', 'idholder'), ('type', 'typeholder')]) - tod.update(task) - tlist_od.append(tod) - - with open(filename, 'w') as fh: - # yaml.dump(tlist_od, fh, default_flow_style=False, sort_keys=False) - yaml.dump(tlist_od, fh, default_flow_style=False) - - -def load_workflow(filename): - """ - load the yaml file to Python objects - - Arguments - ------- - filename: str - the filename pointing to the yaml file in the filesystem - Returns - ----- - object - the Python objects representing the nodes in the graph - - """ - - with open(filename) as f: - obj = yaml.safe_load(f) - return obj - - -def __find_roots(node, inputs, consider_load=True): - """ - find the root nodes that the `node` dependes on - - Arguments - ------- - node: Node - the leaf node, of whom we need to find the dependent input nodes - inputs: list - resulting list to store all the root nodes in this list - consider_load: bool - whether it skips the node which are loading cache file or not - Returns - ----- - None - - """ - - if (node.visited): - return - node.visited = True - if len(node.inputs) == 0: - inputs.append(node) - return - if consider_load and node.load: - inputs.append(node) - return - for i in node.inputs: - __find_roots(i, inputs, consider_load) - - -def build_workflow(task_list, replace=None): - """ - compute the graph structure of the nodes. It will set the input and output - nodes for each of the node - - Arguments - ------- - task_list: list - A list of Python dicts. Each dict is a task node spec. - replace: dict - conf parameters replacement - - Returns - ----- - dict - keys are Node unique ids - values are instances of Node subclasses i.e. plugins. - - """ - replace = dict() if replace is None else replace - task_dict = {} - task_spec_dict = {} - # instantiate objects - for task_spec in task_list: - if task_spec['id'] in replace: - task_spec = copy.deepcopy(task_spec) - task_spec.update(replace[task_spec['id']]) - - if isinstance(task_spec['type'], str): - if 'filepath' in task_spec: - spec = importlib.util.spec_from_file_location(task_spec['id'], - task_spec['filepath']) - mod = importlib.util.module_from_spec(spec) - spec.loader.exec_module(mod) - NodeClass = getattr(mod, task_spec['type']) - else: - NodeClass = getattr(mod_lib, task_spec['type']) - elif issubclass(task_spec['type'], Node): - NodeClass = task_spec['type'] - else: - raise "Not supported" - - load = False - save = False - - if 'load' in task_spec: - load = task_spec['load'] - - if 'save' in task_spec: - save = task_spec['save'] - - instance = NodeClass(task_spec['id'], task_spec['conf'], load, save) - task_dict[task_spec['id']] = instance - task_spec_dict[task_spec['id']] = task_spec - - # build the graph - for task_id in task_dict: - instance = task_dict[task_id] - for input_id in task_spec_dict[task_id]['inputs']: - input_instance = task_dict[input_id] - instance.inputs.append(input_instance) - input_instance.outputs.append(instance) - - # this part is to do static type checks - raw_inputs = [] - for k in task_dict.keys(): - __find_roots(task_dict[k], raw_inputs, consider_load=False) - - for i in raw_inputs: - i.columns_flow() - - # clean up the visited status for run computations - for task_id in task_dict: - task_dict[task_id].visited = False - - return task_dict - - -def viz_graph(obj): - """ - Generate the visulization of the graph in the JupyterLab - - Arguments - ------- - obj: list - a list of Python object that defines the nodes - Returns - ----- - nx.DiGraph - """ - G = nx.DiGraph() - # instantiate objects - for o in obj: - for i in o['inputs']: - G.add_edge(i, o['id']) - return G - - -def run(obj, outputs, replace=None): - """ - Flow the dataframes in the graph to do the data science computations. - - Arguments - ------- - obj: list - a list of Python object that defines the nodes - outputs: list - a list of the leaf node IDs for which to return the final results - replace: list - a dict that defines the conf parameters replacement - - Returns - ----- - tuple - the results corresponding to the outputs list - """ - replace = dict() if replace is None else replace - task_dict = build_workflow(obj, replace) - output_node = Node('unique_output', {}) - # want to save the intermediate results - output_node.clear_input = False - results = [] - results_obj = [] - for o in outputs: - o_obj = task_dict[o] - results_obj.append(o_obj) - output_node.inputs.append(o_obj) - o_obj.outputs.append(output_node) - - inputs = [] - __find_roots(output_node, inputs, consider_load=True) - # now clean up the graph, removed the node that is not used for computation - for key in task_dict: - current_obj = task_dict[key] - if not current_obj.visited: - for i in current_obj.inputs: - i.outputs.remove(current_obj) - current_obj.inputs = [] - - for i in inputs: - i.flow() - - for r_obj in results_obj: - results.append(output_node.input_df[r_obj]) - - # clean the results afterwards - output_node.input_df = {} - return tuple(results) diff --git a/gquant/flow.py b/gquant/flow.py index e8435e18..9a36d2b7 100644 --- a/gquant/flow.py +++ b/gquant/flow.py @@ -1,4 +1,4 @@ -from gquant.dataframe_flow import load_workflow, run +from gquant.dataframe_flow import TaskGraph import argparse @@ -8,10 +8,13 @@ def main(): parser.add_argument('-t', '--task', help="the yaml task file") parser.add_argument('output', help="the output nodes", nargs='+') args = parser.parse_args() + import pudb + pudb.set_trace() - obj = load_workflow(args.task) + task_graph = TaskGraph.load_workflow(args.task) print('output nodes:', args.output) - run(obj, args.output) + task_graph.run(args.output) + if __name__ == "__main__": main() diff --git a/gquant/plugin_nodes/analysis/barPlotNode.py b/gquant/plugin_nodes/analysis/barPlotNode.py index 1aa02742..421a6d4e 100644 --- a/gquant/plugin_nodes/analysis/barPlotNode.py +++ b/gquant/plugin_nodes/analysis/barPlotNode.py @@ -29,7 +29,6 @@ def process(self, inputs): stock = inputs[0] num_points = self.conf['points'] stride = max(len(stock) // num_points, 1) - print('bar plot', len(stock), stride) label = 'stock' if 'label' in self.conf: label = self.conf['label'] diff --git a/gquant/plugin_nodes/analysis/cumReturnNode.py b/gquant/plugin_nodes/analysis/cumReturnNode.py index b98f4219..9a11c6cc 100644 --- a/gquant/plugin_nodes/analysis/cumReturnNode.py +++ b/gquant/plugin_nodes/analysis/cumReturnNode.py @@ -33,7 +33,6 @@ def process(self, inputs): label = self.conf['label'] num_points = self.conf['points'] stride = max(len(input_df) // num_points, 1) - print('cumulative return', len(input_df), stride) date_co = DateScale() linear_co = LinearScale() yax = Axis(label='Cumulative return', scale=linear_co, diff --git a/gquant/plugin_nodes/strategy/__init__.py b/gquant/plugin_nodes/strategy/__init__.py index c9eaca15..4a15dcf8 100644 --- a/gquant/plugin_nodes/strategy/__init__.py +++ b/gquant/plugin_nodes/strategy/__init__.py @@ -1,7 +1,9 @@ from .movingAverageStrategyNode import MovingAverageStrategyNode from .portExpMovingAverageStrategyNode import ( PortExpMovingAverageStrategyNode, CpuPortExpMovingAverageStrategyNode) +from .xgboostStrategyNode import XGBoostStrategyNode __all__ = ["MovingAverageStrategyNode", "PortExpMovingAverageStrategyNode", - "CpuPortExpMovingAverageStrategyNode"] + "CpuPortExpMovingAverageStrategyNode", + "XGBoostStrategyNode"] diff --git a/gquant/plugin_nodes/strategy/xgboostStrategyNode.py b/gquant/plugin_nodes/strategy/xgboostStrategyNode.py new file mode 100644 index 00000000..b78ae43d --- /dev/null +++ b/gquant/plugin_nodes/strategy/xgboostStrategyNode.py @@ -0,0 +1,153 @@ +from gquant.dataframe_flow import Node +import datetime +import cudf +import xgboost as xgb +from numba import cuda +import math + + +__all__ = ['XGBoostStrategyNode'] + + +@cuda.jit +def signal_kernel(signal_arr, out_arr, arr_len): + i = cuda.grid(1) + if i == 0: + out_arr[i] = math.inf + if i < arr_len - 1: + if math.isnan(signal_arr[i]): + out_arr[i + 1] = math.inf + elif signal_arr[i] < 0.0: + # shift 1 time to make sure no peeking into the future + out_arr[i + 1] = -1.0 + else: + out_arr[i + 1] = 1.0 + + +def compute_signal(signal): + signal_arr = signal.data.to_gpu_array() + out_arr = cuda.device_array_like(signal_arr) + number_of_threads = 256 + array_len = len(signal) + number_of_blocks = (array_len + ( + number_of_threads - 1)) // number_of_threads + signal_kernel[(number_of_blocks,), + (number_of_threads,)](signal_arr, + out_arr, + array_len) + return out_arr + + +class XGBoostStrategyNode(Node): + """ + This is the Node used to compute trading signal from XGBoost Strategy. + It requires the following conf fields: + "train_date": a date string of "Y-m-d" format. All the data points + before this date is considered as training, otherwise as testing. If + not provided, all the data points are considered as training. + "xgboost_parameters": a dictionary of any legal parameters for XGBoost + models. It overwrites the default parameters used in the process method + "no_feature": specifying a list of columns in the input dataframe that + should NOT be considered as training features. + "target": the column that is considered as "target" in machine learning + algorithm + It requires the "datetime" column for spliting the data points and adds a + new column "signal" to be used for backtesting. + The detailed computation steps are listed in the process method's docstring + """ + + def columns_setup(self): + self.required = {'datetime': 'datetime64[ms]'} + self.retention = self.conf['no_feature'] + self.retention['signal'] = 'float64' + + def process(self, inputs): + """ + The process is doing following things: + 1. split the data into training and testing based on provided + conf['train_date']. If it is not provided, all the data is + treated as training data. + 2. train a XGBoost model based on the training data + 3. Make predictions for all the data points including training and + testing. + 4. From the prediction of returns, compute the trading signals that + can be used in the backtesting. + Arguments + ------- + inputs: list + list of input dataframes. + Returns + ------- + dataframe + """ + dxgb_params = { + 'nround': 100, + 'max_depth': 8, + 'max_leaves': 2 ** 8, + 'alpha': 0.9, + 'eta': 0.1, + 'gamma': 0.1, + 'learning_rate': 0.1, + 'subsample': 1, + 'reg_lambda': 1, + 'scale_pos_weight': 2, + 'min_child_weight': 30, + 'tree_method': 'gpu_hist', + 'n_gpus': 1, + 'distributed_dask': True, + 'loss': 'ls', + # 'objective': 'gpu:reg:linear', + 'objective': 'reg:squarederror', + 'max_features': 'auto', + 'criterion': 'friedman_mse', + 'grow_policy': 'lossguide', + 'verbose': True + } + if 'xgboost_parameters' in self.conf: + dxgb_params.update(self.conf['xgboost_parameters']) + input_df = inputs[0] + model_df = input_df + if 'train_date' in self.conf: + train_date = datetime.datetime.strptime(self.conf['train_date'], # noqa: F841, E501 + '%Y-%m-%d') + model_df = model_df.query('datetime<@train_date') + train_cols = set(model_df.columns) - set( + self.conf['no_feature'].keys()) + train_cols = list(train_cols - set([self.conf['target']])) + pd_model = model_df.to_pandas() + train = pd_model[train_cols] + target = pd_model[self.conf['target']] + dmatrix = xgb.DMatrix(train, target) + bst = xgb.train(dxgb_params, dmatrix, + num_boost_round=dxgb_params['nround']) + # make inferences + infer_dmatrix = xgb.DMatrix(input_df.to_pandas()[train_cols]) + prediction = cudf.Series(bst.predict(infer_dmatrix)).astype('float64') + signal = compute_signal(prediction) + input_df['signal'] = signal + # remove the bad datapints + input_df = input_df.query('signal<10') + remaining = list(self.conf['no_feature'].keys()) + ['signal'] + return input_df[remaining] + + +if __name__ == "__main__": + from gquant.plugin_nodes.dataloader.csvStockLoader import CsvStockLoader + + loader = CsvStockLoader("node_technical_indicator", {}, True, False) + df = loader.load_cache('.cache'+'/'+loader.uid+'.hdf5') + conf = { + 'train_date': '2010-1-1', + 'target': 'SHIFT_-1', + 'no_feature': {'asset': 'int64', + 'datetime': 'datetime64[ms]', + 'volume': 'float64', + 'close': 'float64', + 'open': 'float64', + 'high': 'float64', + 'low': 'float64', + 'returns': 'float64', + 'indicator': 'int32'} + } + inN = XGBoostStrategyNode("abc", conf) + o = inN.process([df]) diff --git a/gquant/plugin_nodes/transform/__init__.py b/gquant/plugin_nodes/transform/__init__.py index 0ca88cf1..1d68966c 100644 --- a/gquant/plugin_nodes/transform/__init__.py +++ b/gquant/plugin_nodes/transform/__init__.py @@ -4,16 +4,17 @@ from .returnFeatureNode import ReturnFeatureNode, CpuReturnFeatureNode from .sortNode import SortNode from .volumeFilterNode import VolumeFilterNode -from .datetimeFliterNode import DatetimeFilterNode +from .datetimeFilterNode import DatetimeFilterNode from .minNode import MinNode from .maxNode import MaxNode from .valueFilterNode import ValueFilterNode from .renameNode import RenameNode from .assetIndicatorNode import AssetIndicatorNode, CpuAssetIndicatorNode from .dropNode import DropNode +from .indicatorNode import IndicatorNode __all__ = ["AverageNode", "AssetFilterNode", "LeftMergeNode", "ReturnFeatureNode", "CpuReturnFeatureNode", "SortNode", "VolumeFilterNode", "DatetimeFilterNode", "MinNode", "MaxNode", "ValueFilterNode", "RenameNode", "AssetIndicatorNode", - "CpuAssetIndicatorNode", "DropNode"] + "CpuAssetIndicatorNode", "DropNode", "IndicatorNode"] diff --git a/gquant/plugin_nodes/transform/datetimeFliterNode.py b/gquant/plugin_nodes/transform/datetimeFilterNode.py similarity index 57% rename from gquant/plugin_nodes/transform/datetimeFliterNode.py rename to gquant/plugin_nodes/transform/datetimeFilterNode.py index 8642f5f9..d19c8e77 100644 --- a/gquant/plugin_nodes/transform/datetimeFliterNode.py +++ b/gquant/plugin_nodes/transform/datetimeFilterNode.py @@ -2,7 +2,17 @@ import datetime +__all__ = ['DatetimeFilterNode'] + + class DatetimeFilterNode(Node): + """ + A node that is used to select datapoints based on range of time. + conf["beg"] defines the beginning of the date inclusively and + conf["end"] defines the end of the date exclusively. + all the date strs are in format of "Y-m-d". + + """ def process(self, inputs): """ @@ -17,9 +27,14 @@ def process(self, inputs): ------- dataframe """ - beg_date = datetime.datetime.strptime(self.conf['beg'], '%Y-%m-%d') # noqa: F841 - end_date = datetime.datetime.strptime(self.conf['end'], '%Y-%m-%d') # noqa: F841 - return df.query('datetime<@end_date and datetime>=@beg_date') + df = inputs[0] + beg_date = \ + datetime.datetime.strptime(self.conf['beg'], '%Y-%m-%d') + end_date = \ + datetime.datetime.strptime(self.conf['end'], '%Y-%m-%d') + return df.query('datetime<@end_date and datetime>=@beg_date', + local_dict={'beg_date': beg_date, + 'end_date': end_date}) def columns_setup(self): self.required = {"datetime": "datetime64[ms]"} diff --git a/gquant/plugin_nodes/transform/indicatorNode.py b/gquant/plugin_nodes/transform/indicatorNode.py new file mode 100644 index 00000000..3e30bb48 --- /dev/null +++ b/gquant/plugin_nodes/transform/indicatorNode.py @@ -0,0 +1,100 @@ +from gquant.dataframe_flow import Node +import numpy as np +import gquant.cuindicator as ci + + +class IndicatorNode(Node): + + def columns_setup(self): + self.required = {'indicator': 'int32'} + self.addition = {} + indicators = self.conf['indicators'] + for indicator in indicators: + for col in indicator['columns']: + self.required[col] = 'float64' + if 'outputs' in indicator: + for out in indicator['outputs']: + out_col = self._compose_name(indicator, [out]) + self.addition[out_col] = 'float64' + else: + out_col = self._compose_name(indicator, []) + self.addition[out_col] = 'float64' + + def _compose_name(self, indicator, outname=[]): + name = indicator['function'] + args_name = [] + if 'args' in indicator: + args_name = [str(i) for i in indicator['args']] + + splits = [i.upper() for i in name.split('_') if i != 'port'] + if len(splits) > 2: + splits = [i[0] for i in splits] + outname + args_name + elif len(splits) == 2: + splits = [i[0:2] for i in splits] + outname + args_name + else: + splits = [splits[0]] + outname + args_name + return "_".join(splits) + + def process(self, inputs): + """ + Add technical indicators to the dataframe. + All technical indicators are defined in the self.conf + "remove_na" in self.conf decides whether we want to remove the NAs + from the technical indicators + + Arguments + ------- + inputs: list + list of input dataframes. + Returns + ------- + dataframe + """ + input_df = inputs[0] + indicators = self.conf['indicators'] + out_cols = [] + for indicator in indicators: + fun = getattr(ci, indicator['function']) + parallel = [input_df['indicator']] + data = [input_df[col] for col in indicator['columns']] + ar = [] + if 'args' in indicator: + ar = indicator['args'] + v = fun(*(parallel+data+ar)) + if isinstance(v, tuple) and 'outputs' in indicator: + for out in indicator['outputs']: + out_col = self._compose_name(indicator, [out]) + input_df[out_col] = getattr(v, out) + out_cols.append(out_col) + else: + out_col = self._compose_name(indicator, []) + input_df[out_col] = v + out_cols.append(out_col) + # remove all the na elements, requires cudf>=0.8 + if "remove_na" in self.conf and self.conf["remove_na"]: + na_element = input_df[out_cols[0]].isna() + for i in range(1, len(out_cols)): + na_element |= input_df[out_cols[i]].isna() + input_df = input_df.iloc[np.where((~na_element).to_array())[0]] + return input_df + + +if __name__ == "__main__": + from gquant.plugin_nodes.dataloader.csvStockLoader import CsvStockLoader + + loader = CsvStockLoader("node_sort2", {}, True, False) + df = loader.load_cache('.cache'+'/'+loader.uid+'.hdf5') + conf = { + "indicators": [ + {"function": "port_chaikin_oscillator", + "columns": ["high", "low", "close", "volume"], + "args": [10, 20]}, + {"function": "port_bollinger_bands", + "columns": ["close"], + "args": [10], + "outputs": ["b1", "b2"]} + ], + "remove_na": True + } + inN = IndicatorNode("abc", conf) + o = inN.process([df]) diff --git a/notebook/01_tutorial.ipynb b/notebook/01_tutorial.ipynb index c2a8a3f7..de31efa4 100644 --- a/notebook/01_tutorial.ipynb +++ b/notebook/01_tutorial.ipynb @@ -4,38 +4,63 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### gquant Tutorial Intro\n", + "# Introduction to gQuant\n", "\n", - "gQuant is a quantitative framework built on top of RAPIDS in the Python language. The computing components of gquant are oriented around its plugins and dataframe workflows. Let's begin by importing `nxpd` (Python package for visualization NetworkX graphs using pydot) and the dataframe workflow component of gQuant." + "**gQuant** is a set of open-source examples for Quantitative Analysis tasks:\n", + "- Data preparation & feat. engineering\n", + "- Alpha seeking modeling\n", + "- Technical indicators\n", + "- Backtesting\n", + "\n", + "It is GPU-accelerated by leveraging [**RAPIDS.ai**](https://rapids.ai) technology, and has Multi-GPU and Multi-Node support.\n", + "\n", + "gQuant computing components are oriented around its plugins and task graph.\n", + "\n", + "## Download example datasets\n", + "\n", + "Before getting started, let's download the example datasets if not present." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset is already present. No need to re-download it.\n" + ] + } + ], "source": [ - "# Import python libs used throughout\n", - "import os\n", - "import warnings\n", - "import nxpd\n", - "import gquant.dataframe_flow as dff" + "! ((test ! -f './data/stock_price_hist.csv.gz' || test ! -f './data/security_master.csv.gz') && \\\n", + " cd .. && bash download_data.sh) || echo \"Dataset is already present. No need to re-download it.\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In this tutorial, we are going to use gquant to do a simple quant job. The job tasks are listed below:\n", - " 1. load csv stock data\n", - " 2. filter out the stocks that has average volume smaller than 50\n", - " 3. sort the stock symbols and datetime\n", - " 4. add rate of return as a feature into the table\n", - " 5. In two branches, compute the mean volume and mean return seperately\n", - " 6. read the stock symbol name file and join the computed dataframes\n", - " 7. output the result in csv files\n", + "## About this notebook\n", + "\n", + "In this tutorial, we are going to use gQuant to do a simple quant job. The job tasks are listed below:\n", + " 1. load csv stock data.\n", + " 2. filter out the stocks that has average volume smaller than 50.\n", + " 3. sort the stock symbols and datetime.\n", + " 4. add rate of return as a feature into the table.\n", + " 5. in two branches, computethe mean volume and mean return.\n", + " 6. read the file containing the stock symbol names, and join the computed dataframes.\n", + " 7. output the result in csv files.\n", + " \n", + "## Task graphs, nodes and plugins\n", + "\n", + "Quant processing operators are defined as nodes that operates on **cuDF**/**dask_cuDF** dataframes.\n", + "\n", + "A **task graph** is a list of tasks composed of gQuant nodes.\n", "\n", - "Using gquant each task can be thought of as a node that operates on cudf dataframes. We formulate a task list or workflow by using these nodes. Below we write the schema for the tasks above." + "The cell below contains the task graph described before." ] }, { @@ -44,109 +69,94 @@ "metadata": {}, "outputs": [], "source": [ + "import sys; sys.path.append('..')\n", + "import warnings; warnings.simplefilter(\"ignore\")\n", + "\n", + "from gquant.dataframe_flow import TaskSpecSchema \n", + "\n", "# load csv stock data\n", "task_csvdata = {\n", - " 'id': 'node_csvdata',\n", - " 'type': 'CsvStockLoader',\n", - " 'conf': {\n", - " 'path': './data/stock_price_hist.csv.gz'\n", - " },\n", - " 'inputs': []\n", + " TaskSpecSchema.task_id: 'load_csv_data',\n", + " TaskSpecSchema.node_type: 'CsvStockLoader',\n", + " TaskSpecSchema.conf: {'path': './data/stock_price_hist.csv.gz'},\n", + " TaskSpecSchema.inputs: []\n", "}\n", "\n", "# filter out the stocks that has average volume smaller than 50\n", "task_minVolume = {\n", - " 'id': 'node_minVolume',\n", - " 'type': 'VolumeFilterNode',\n", - " 'conf': {\n", - " 'min': 50.0\n", - " },\n", - " 'inputs': ['node_csvdata']\n", + " TaskSpecSchema.task_id: 'min_volume',\n", + " TaskSpecSchema.node_type: 'VolumeFilterNode',\n", + " TaskSpecSchema.conf: {'min': 50.0},\n", + " TaskSpecSchema.inputs: ['load_csv_data']\n", "}\n", "\n", "# sort the stock symbols and datetime\n", "task_sort = {\n", - " 'id': 'node_sort',\n", - " 'type': 'SortNode',\n", - " 'conf': {\n", - " 'keys': ['asset', 'datetime']\n", - " },\n", - " 'inputs': ['node_minVolume']\n", + " TaskSpecSchema.task_id: 'sort',\n", + " TaskSpecSchema.node_type: 'SortNode',\n", + " TaskSpecSchema.conf: {'keys': ['asset', 'datetime']},\n", + " TaskSpecSchema.inputs: ['min_volume']\n", "}\n", "\n", "# add rate of return as a feature into the table\n", "task_addReturn = {\n", - " 'id': 'node_addReturn',\n", - " 'type': 'ReturnFeatureNode',\n", - " 'conf': {},\n", - " 'inputs': ['node_sort']\n", + " TaskSpecSchema.task_id: 'add_return',\n", + " TaskSpecSchema.node_type: 'ReturnFeatureNode',\n", + " TaskSpecSchema.conf: {},\n", + " TaskSpecSchema.inputs: ['sort']\n", "}\n", "\n", "# read the stock symbol name file and join the computed dataframes\n", "task_stockSymbol = {\n", - " 'id': 'node_stockSymbol',\n", - " 'type': 'StockNameLoader',\n", - " 'conf': {\n", - " 'path': './data/security_master.csv.gz'\n", - " },\n", - " 'inputs': []\n", + " TaskSpecSchema.task_id: 'stock_symbol',\n", + " TaskSpecSchema.node_type: 'StockNameLoader',\n", + " TaskSpecSchema.conf: {'path': './data/security_master.csv.gz'},\n", + " TaskSpecSchema.inputs: []\n", "}\n", "\n", "# In two branches, compute the mean volume and mean return seperately\n", "task_volumeMean = {\n", - " 'id': 'node_volumeMean',\n", - " 'type': 'AverageNode',\n", - " 'conf': {\n", - " 'column': 'volume'\n", - " },\n", - " 'inputs': ['node_addReturn']\n", + " TaskSpecSchema.task_id: 'volume_mean',\n", + " TaskSpecSchema.node_type: 'AverageNode',\n", + " TaskSpecSchema.conf: {'column': 'volume'},\n", + " TaskSpecSchema.inputs: ['add_return']\n", "}\n", "\n", "task_returnMean = {\n", - " 'id': 'node_returnMean',\n", - " 'type': 'AverageNode',\n", - " 'conf': {\n", - " 'column': 'returns'\n", - " },\n", - " 'inputs': ['node_addReturn']\n", + " TaskSpecSchema.task_id: 'return_mean',\n", + " TaskSpecSchema.node_type: 'AverageNode',\n", + " TaskSpecSchema.conf: {'column': 'returns'},\n", + " TaskSpecSchema.inputs: ['add_return']\n", "}\n", "\n", "task_leftMerge1 = {\n", - " 'id': 'node_leftMerge1',\n", - " 'type': 'LeftMergeNode',\n", - " 'conf': {\n", - " 'column': 'asset'\n", - " },\n", - " 'inputs': ['node_volumeMean', 'node_stockSymbol']\n", + " TaskSpecSchema.task_id: 'left_merge_1',\n", + " TaskSpecSchema.node_type: 'LeftMergeNode',\n", + " TaskSpecSchema.conf: {'column': 'asset'},\n", + " TaskSpecSchema.inputs: ['volume_mean', 'stock_symbol']\n", "}\n", "\n", "task_leftMerge2 = {\n", - " 'id': 'node_leftMerge2',\n", - " 'type': 'LeftMergeNode',\n", - " 'conf': {\n", - " 'column': 'asset'\n", - " },\n", - " 'inputs': ['node_returnMean', 'node_stockSymbol']\n", + " TaskSpecSchema.task_id: 'left_merge_2',\n", + " TaskSpecSchema.node_type: 'LeftMergeNode',\n", + " TaskSpecSchema.conf: {'column': 'asset'},\n", + " TaskSpecSchema.inputs: ['return_mean', 'stock_symbol']\n", "}\n", "\n", "# output the result in csv files\n", "\n", "task_outputCsv1 = {\n", - " 'id': 'node_outputCsv1',\n", - " 'type': 'OutCsvNode',\n", - " 'conf': {\n", - " 'path': 'symbol_volume.csv'\n", - " },\n", - " 'inputs': ['node_leftMerge1']\n", + " TaskSpecSchema.task_id: 'output_csv_1',\n", + " TaskSpecSchema.node_type: 'OutCsvNode',\n", + " TaskSpecSchema.conf: {'path': 'symbol_volume.csv'},\n", + " TaskSpecSchema.inputs: ['left_merge_1']\n", "}\n", "\n", "task_outputCsv2 = {\n", - " 'id': 'node_outputCsv2',\n", - " 'type': 'OutCsvNode',\n", - " 'conf': {\n", - " 'path': 'symbol_returns.csv'\n", - " },\n", - " 'inputs': ['node_leftMerge2']\n", + " TaskSpecSchema.task_id: 'output_csv_2',\n", + " TaskSpecSchema.node_type: 'OutCsvNode',\n", + " TaskSpecSchema.conf: {'path': 'symbol_returns.csv'},\n", + " TaskSpecSchema.inputs: ['left_merge_2']\n", "}" ] }, @@ -154,267 +164,203 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A task schema defined in python is a dictionary with the following fields: `id`, `type`, `conf`, `inputs`, and `filepath`. Additionally there is a `load` and a `save` field used for running workflows (described later on). The `id` for a given task must be unique within a workflow. Tasks use the `id` field in their `inputs` field for specifying that the output(s) of other tasks are inputs. The `type` is the class of the compute task or plugin. The gquant framework already implements a number of such plugins. These can be found in `gquant.plugin_nodes`. For example:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "class VolumeFilterNode(Node):\n", - "\n", - " def columns_setup(self):\n", - " self.required = {\"asset\": \"int64\",\n", - " \"volume\": \"float64\"}\n", - " self.addition = {\"mean_volume\": \"float64\"}\n", - "\n", - " def process(self, inputs):\n", - " \"\"\"\n", - " filter the dataframe based on the min and max values of the average\n", - " volume for each fo the assets.\n", - "\n", - " Arguments\n", - " -------\n", - " inputs: list\n", - " list of input dataframes.\n", - " Returns\n", - " -------\n", - " dataframe\n", - " \"\"\"\n", - "\n", - " input_df = inputs[0]\n", - " volume_df = input_df[['volume', \"asset\"]].groupby(\n", - " [\"asset\"]).mean().reset_index()\n", - " volume_df.columns = [\"asset\", 'mean_volume']\n", - " merged = input_df.merge(volume_df, on=\"asset\", how='left')\n", - " if 'min' in self.conf:\n", - " minVolume = self.conf['min']\n", - " merged = merged.query('mean_volume >= %f' % (minVolume))\n", - " if 'max' in self.conf:\n", - " maxVolume = self.conf['max']\n", - " merged = merged.query('mean_volume <= %f' % (maxVolume))\n", - " return merged\n", - "\n" - ] - } - ], - "source": [ - "import inspect\n", - "from gquant.plugin_nodes.transform import VolumeFilterNode\n", + "In Python, a gQuant task-spec is defined as a dictionary with the following fields:\n", + "- `id`\n", + "- `type`\n", + "- `conf`\n", + "- `inputs`\n", + "- `filepath`\n", "\n", - "print(inspect.getsource(VolumeFilterNode))" + "As a best practice, we recommend using the `TaskSpecSchema` class for these fields, instead of strings.\n", + "\n", + "The `id` for a given task must be unique within a task graph. To use the result(s) of other task(s) as input(s) of a different task, we use the id(s) of the former task(s) in the `inputs` field of the next task.\n", + "\n", + "The `type` field contains the node type to use for the compute task. gQuant includes a collection of node classes. These can be found in `gquant.plugin_nodes`. Click [here](#node_class_example) to see a gQuant node class example.\n", + "\n", + "The `conf` field is used to parameterise a task. It lets you access user-set parameters within a plugin (such as `self.conf['min']` in the example above).\n", + "\n", + "The `filepath` field is used to specify a python module where a custom plugin is defined. It is optional if the plugin is in `plugin_nodes` directory, and mandatory when the plugin is somewhere else. In a different tutorial, we will learn how to create custom plugins.\n", + "\n", + "A custom node schema will look something like this:\n", + "```\n", + "custom_task = {\n", + " TaskSpecSchema.task_id: 'custom_calc',\n", + " TaskSpecSchema.node_type: 'CustomNode',\n", + " TaskSpecSchema.conf: {},\n", + " TaskSpecSchema.inputs: ['some_other_node'],\n", + " TaskSpecSchema.filepath: 'custom_nodes.py'\n", + "}\n", + "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The `conf` field is the configuration field. It is used to parameterize a task. The `conf` can be used to access user set parameters within a plugin (such as `self.conf['min']` in example above). The `filepath` is used to specify a python module where a custom plugin is defined. In another tutorial we go over how to create custom plugins. A custom node schema could look something like:\n", - "```\n", - "custom_task = {\n", - " 'id': 'node_custom_calc',\n", - " 'type': 'CustomNode',\n", - " 'conf': {},\n", - " 'inputs': ['some_other_node'],\n", - " 'filepath': 'custom_nodes.py'\n", - "}\n", - "```\n", - "Below we define our complete workflow and visualize it as a graph." + "Below, we compose our task graph and visualize it as a graph." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "import nxpd\n", + "from gquant.dataframe_flow import TaskGraph\n", + "\n", + "# list of nodes composing the task graph\n", "task_list = [\n", " task_csvdata, task_minVolume, task_sort, task_addReturn,\n", " task_stockSymbol, task_volumeMean, task_returnMean,\n", " task_leftMerge1, task_leftMerge2,\n", " task_outputCsv1, task_outputCsv2]\n", "\n", - "task_graph = dff.viz_graph(task_list)\n", - "nxpd.draw(task_graph, show='ipynb')" + "task_graph = TaskGraph(task_list)\n", + "nxpd.draw(task_graph.viz_graph(), show='ipynb')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The workflow can now be saved to a yaml file for future re-use." + "We will use `save_taskgraph` method to save the task graph to a **yaml file**.\n", + "\n", + "That will allow us to re-use it in the future." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Workflow File: /tmp/wflow_60eny_2m.yaml\n" - ] - } - ], + "outputs": [], "source": [ - "from tempfile import NamedTemporaryFile\n", + "task_graph_file_name = '01_tutorial_task_graph.yaml'\n", "\n", - "wflow_file = NamedTemporaryFile(prefix='wflow_', suffix='.yaml', delete=False)\n", - "wflow_file.close()\n", - "dff.save_workflow(task_list, wflow_file.name)\n", - "\n", - "print('Workflow File: {}'.format(wflow_file.name))" + "task_graph.save_taskgraph(task_graph_file_name)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Here is a snippet of the contents in the resulting yaml file:" + "Here is a snippet of the content in the resulting yaml file:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "- id: node_csvdata\n", + "- id: load_csv_data\n", " type: CsvStockLoader\n", " conf:\n", " path: ./data/stock_price_hist.csv.gz\n", " inputs: []\n", - "- id: node_minVolume\n", + "- id: min_volume\n", " type: VolumeFilterNode\n", " conf:\n", " min: 50.0\n", " inputs:\n", - " - node_csvdata\n", - "- id: node_sort\n", + " - load_csv_data\n", + "- id: sort\n", " type: SortNode\n", " conf:\n", " keys:\n", " - asset\n", " - datetime\n", " inputs:\n", - " - node_minVolume\n", - "- id: node_addReturn\n", - " type: ReturnFeatureNode\n", - " conf: {}\n", - " inputs:\n", - " - node_sort\n", - "- id: node_stockSymbol\n", - " type: StockNameLoader\n", - " conf:\n", - " path: ./data/security_master.csv.gz\n", - " inputs: []\n", - "\n" + " - min_volume\n" ] } ], "source": [ - "N = 29\n", - "with open(wflow_file.name) as myfile:\n", - " head = [next(myfile) for x in range(N)]\n", - "\n", - "print(''.join(head))" + "%%bash -s \"$task_graph_file_name\"\n", + "head -n 19 $1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The yaml file describes the computation tasks. We can load it and visualize it as a graph. Note, that since the individual tasks can be parameterized, the overall workflow can be parameterized as well. In this manner the workflow can be reused dynamically. " + "The yaml file describes the computation tasks. We can load it and visualize it as a graph." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "task_list = dff.load_workflow(wflow_file.name)\n", - "task_graph = dff.viz_graph(task_list)\n", - "nxpd.draw(task_graph, show='ipynb')" + "task_graph = TaskGraph.load_taskgraph(task_graph_file_name)\n", + "nxpd.draw(task_graph.viz_graph(), show='ipynb')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Building and running a workflow\n", + "## Building a task graph\n", + "\n", + "Running the task graph is the next logical step. Nevertheless, it can optionally be built before running it.\n", + "\n", + "By calling `build` method, the graph is traversed without running the dataframe computations. This could be useful to inspect the column names and types, validate that the plugins can be instantiated, and check for errors.\n", + "\n", + "The output of `build` are instances of each task in a dictionary.\n", "\n", - "The next step would be to run the workflow. Optionally, we can build the workflow prior to running. This could be useful to inspect the column names and types, validate that the plugins can be instantiated, and check for errors. This can be done by calling `build_workflow` function to traverses the workflow graph without running the dataframe computations. In the example below we inspect the column names and types for the inputs and outputs of the `node_leftMerge` task." + "In the example below, we inspect the column names and types for the inputs and outputs of the `left_merge_1` task:" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Output of build workflow are instances of each task in a dictionary:\n", - "{'node_addReturn': ,\n", - " 'node_csvdata': ,\n", - " 'node_leftMerge1': ,\n", - " 'node_leftMerge2': ,\n", - " 'node_minVolume': ,\n", - " 'node_outputCsv1': ,\n", - " 'node_outputCsv2': ,\n", - " 'node_returnMean': ,\n", - " 'node_sort': ,\n", - " 'node_stockSymbol': ,\n", - " 'node_volumeMean': }\n", - "\n", - "\n", - "Input columns in incoming dataframes:\n", - "{: {'asset': 'int64',\n", - " 'asset_name': 'object'},\n", - " : {'asset': 'int64',\n", - " 'volume': 'float64'}}\n", - "\n", - "\n", - "Output columns in outgoing dataframe:\n", - "{'asset': 'int64', 'asset_name': 'object', 'volume': 'float64'}\n", - "\n", + "Output of build task graph are instances of each task in a dictionary:\n", "\n", + "load_csv_data: \n", + "min_volume: \n", + "sort: \n", + "add_return: \n", + "stock_symbol: \n", + "volume_mean: \n", + "return_mean: \n", + "left_merge_1: \n", + "left_merge_2: \n", + "output_csv_1: \n", + "output_csv_2: \n", "\n" ] } @@ -422,160 +368,231 @@ "source": [ "from pprint import pprint\n", "\n", - "task_dict = dff.build_workflow(task_list)\n", - "print('Output of build workflow are instances of each task in a dictionary:')\n", - "pprint(task_dict)\n", - "\n", - "lmerge1_task_instance = task_dict['node_leftMerge1']\n", + "task_graph.build()\n", "\n", - "print('\\n\\nInput columns in incoming dataframes:')\n", - "pprint(lmerge1_task_instance.input_columns)\n", + "print('Output of build task graph are instances of each task in a dictionary:\\n')\n", + "print(str(task_graph))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input columns in incoming dataframes:\n", + "\n", + "{: {'asset': 'int64',\n", + " 'asset_name': 'object'},\n", + " : {'asset': 'int64',\n", + " 'volume': 'float64'}}\n" + ] + } + ], + "source": [ + "# Input columns in 'left_merge_1' node\n", "\n", - "print('\\n\\nOutput columns in outgoing dataframe:')\n", - "pprint(lmerge1_task_instance.output_columns)\n", + "print('Input columns in incoming dataframes:\\n')\n", + "pprint(task_graph['left_merge_1'].input_columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output columns in outgoing dataframe:\n", + "\n", + "{'asset': 'int64', 'asset_name': 'object', 'volume': 'float64'}\n" + ] + } + ], + "source": [ + "# Output columns in 'left_merge_1' node\n", "\n", - "print('\\n\\n')" + "print('Output columns in outgoing dataframe:\\n')\n", + "pprint(task_graph['left_merge_1'].output_columns)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Building the workflow is optional, because the `build_workflow` function is called within `run`, but it is useful for inspection. We use the `run` function to run the dataframe computations. The required `run` function arguments are a task list and outputs list. The `run` also takes an optional `replace` argument which is used and explained later on." + "## Running a task graph\n", + "\n", + "To execute the graph computations, we will use the `run` method.\n", + "\n", + "It requires a tasks list and outputs list. `run` can also takes an optional `replace` argument which is used and explained later on." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "outlist = ['node_csvdata', 'node_outputCsv1', 'node_outputCsv2']\n", - "\n", - "# o = dff.run(task_list, outputs=outlist, replace=replace_spec)\n", - "# csv1_df, csv2_df = dff.run(task_list, outputs=outlist)\n", - "with warnings.catch_warnings():\n", - " warnings.simplefilter('ignore', category=UserWarning)\n", - " csvdata_df, csv1_df, csv2_df = dff.run(task_list, outputs=outlist)" + "outputs = ['load_csv_data', 'output_csv_1', 'output_csv_2']\n", + "csv_data_df, csv_1_df, csv_2_df = task_graph.run(outputs=outputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's inspect the content of `csv_1_df` and `csv_2_df`." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Outputs Csv1 Dataframe:\n", + "csv_1_df content:\n", " asset volume asset_name\n", - "0 869584 673.6252347192939 LPT\n", - "1 869589 110.45606585788563 DSLV\n", - "2 869590 66.60725338491311 BPTH\n", - "3 869592 56.04176626826026 SP\n", - "4 869349 91.1619912790699 VIIX\n", - "5 869357 307.7649913344884 USLV\n", - "6 869358 487.50996732026226 UVE\n", - "7 869363 149.03844827586232 SNOW\n", - "8 869368 130.89174311926593 AMBR\n", - "9 869369 149.52366548042716 IBP\n", + "0 869584 673.6252347192963 LPT\n", + "1 869589 110.45606585788566 DSLV\n", + "2 869590 66.60725338491304 BPTH\n", + "3 869592 56.04176626826022 SP\n", + "4 22252 504.76139573070475 CEF\n", + "5 22254 66.17807660961687 SKYY\n", + "6 22260 401.52754481920374 CLDX\n", + "7 22262 536.560684844641 UNIS\n", + "8 22266 1395.477944969905 PLD\n", + "9 22281 2942.5588980367343 SQQQ\n", "[3674 more rows]\n", "\n", - "Outputs Csv2 Dataframe:\n", - " asset returns asset_name\n", - "0 869584 0.0003694185044968794 LPT\n", - "1 869589 0.001077215924445622 DSLV\n", - "2 869590 0.005320585829942715 BPTH\n", - "3 869592 0.0005018748359261746 SP\n", - "4 869349 0.0047172681011212 VIIX\n", - "5 869357 0.00572973978564648 USLV\n", - "6 869358 0.0013285777584282489 UVE\n", - "7 869363 -2.8580346399647086e-05 SNOW\n", - "8 869368 -0.001582324338745823 AMBR\n", - "9 869369 0.0017413617080852127 IBP\n", - "[3674 more rows]\n", - "\n", - "Csv Files produced:\n", - "\n", - "./symbol_volume.csv\n", - "./symbol_returns.csv\n" + "csv_2_df content:\n", + " asset returns asset_name\n", + "0 869584 0.000369418504496879 LPT\n", + "1 869589 0.0010772159244456239 DSLV\n", + "2 869590 0.005320585829942712 BPTH\n", + "3 869592 0.0005018748359261733 SP\n", + "4 869349 0.004717268101121203 VIIX\n", + "5 869357 0.005729739785646483 USLV\n", + "6 869358 0.0013285777584282476 UVE\n", + "7 869363 -2.858034639964821e-05 SNOW\n", + "8 869368 -0.0015823243387458204 AMBR\n", + "9 869369 0.0017413617080852103 IBP\n", + "[3674 more rows]\n" ] } ], "source": [ - "print('Outputs Csv1 Dataframe:\\n{}'.format(csv1_df))\n", - "print('\\nOutputs Csv2 Dataframe:\\n{}'.format(csv2_df))\n", + "print('csv_1_df content:')\n", + "print(csv_1_df)\n", "\n", - "print('\\nCsv Files produced:\\n')\n", - "!find . -iname \"*symbol*\"" + "print('\\ncsv_2_df content:')\n", + "print(csv_2_df) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Above, we can see that two resulting csv files were generated:\n", + "Also, please notice that two resulting csv files has been created:\n", "- symbol_returns.csv\n", "- symbol_volume.csv" ] }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "csv files created:\n", + "./symbol_returns.csv\n", + "./symbol_volume.csv\n" + ] + } + ], + "source": [ + "print('\\ncsv files created:')\n", + "!find . -iname \"*symbol*\" " + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The nice thing about using a workflow task graph is that we can evaluate a sub-graph. For example, if are interested in the `node_volumeMean` result only, we can run the workflow tasks only relevant for that computation. Additionally, if we do not want to re-run tasks we can use the `replace` argument of the `run` function with a `load` option. The `replace` argument needs to be a dictionary where each key is the task/node id. The values are a replacement task-spec dictionary i.e. where each key is a spec overload and value is what to overload with. In the example below instead of re-running `node_csvdata` that loads `csv` into a `cudf` dataframe, we use its dataframe output above to load from." + "## Subgraphs\n", + "\n", + "A nice feature of task graphs is that we can evaluate any **subgraph**. For instance, if you are only interested in the `volume_mean` result, you can run only the tasks which are relevant for that computation.\n", + "\n", + "If we would not want to re-run tasks, we could also use the `replace` argument of the `run` function with a `load` option.\n", + "\n", + "The `replace` argument needs to be a dictionary where each key is the task/node id. The values are a replacement task-spec dictionary (i.e. each key is a spec overload, and its value is what to overload with).\n", + "\n", + "In the example below, instead of re-running the `load_csv_data` node to load a csv file into a `cudf` dataframe, we will use its dataframe output to load from it." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " asset volume\n", - "0 631 350.26002599934947\n", - "1 914 266.22377358490553\n", - "2 1404 2073.529167746952\n", - "3 1544 80.65922330097092\n", - "4 1545 18922.82686118217\n" + " asset volume\n", + "0 631 350.26002599935015\n", + "1 914 266.2237735849057\n", + "2 1404 2073.5291677469504\n", + "3 1544 80.6592233009711\n", + "4 1545 18922.826861182173\n", + "5 1551 136.9049115913557\n", + "6 1556 255.45487404162145\n", + "7 1562 185.35912167243157\n", + "8 1565 66.3794800371402\n", + "9 1568 948.0509283819628\n", + "[3674 more rows]\n" ] } ], "source": [ - "replace_spec = {\n", - " 'node_csvdata': {\n", - " 'load': csvdata_df,\n", + "replace = {\n", + " 'load_csv_data': {\n", + " 'load': csv_data_df,\n", " 'save': True\n", " }\n", "}\n", "\n", - "with warnings.catch_warnings():\n", - " warnings.simplefilter('ignore', category=UserWarning)\n", - " (volmean_df,) = dff.run(\n", - " task_list,\n", - " outputs=['node_volumeMean'],\n", - " replace=replace_spec)\n", + "(volume_mean_df, ) = task_graph.run(outputs=['volume_mean'],\n", + " replace=replace)\n", "\n", - "print(volmean_df.head())" + "print(volume_mean_df)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As a convenience we can save the check points for any of the nodes in the graph on disk and re-load. This is done by specifying boolean `True` for the save option. In the example above the `replace_spec` directs `run` to save on disk for the `node_csvdata`. If `load` was boolean then the data would be loaded from disk presuming the data was saved to disk in a prior run. The default directory for saving is `/.cache/.hdf5`. PyTables is required for the saving to disk functionality. Install via:\n", - "```\n", - "conda install -c anaconda pytables\n", - "```\n", + "As a convenience, we can save on disk the checkpoints for any of the nodes, and re-load them if needed. It is only needed to set the save option to `True`.\n", + "\n", + "In the example above, the `replace` spec directs `run` to save on disk for the `load_csv_data`. If `load` was boolean then the data would be loaded from disk presuming the data was saved to disk in a prior run.\n", "\n", - "The replace spec is also used for overriding parameters in the tasks. For example, in the task `node_minVolume` if instead of `50.0` we wanted to use `40.0` our replace spec would be:\n", + "The default directory for saving is `/.cache/.hdf5`.\n", + "\n", + "`replace` is also used to override parameters in the tasks. For instance, if we wanted to use the value `40.0` instead `50.0` in the task `min_volume`, we would do something similar to:\n", "```\n", "replace_spec = {\n", - " 'node_minVolume': {\n", + " 'min_volume': {\n", " 'conf': {\n", " 'min': 40.0\n", " }\n", @@ -585,65 +602,60 @@ "```" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If we want to evalute a particular task multiple times it does not make sense to re-run everything from the very beginning. For example, we can save the `node_returnMean` result on disk." - ] - }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Return Mean Dataframe:\n", - " asset returns\n", - "0 631 2.579372358333649e-05\n", - "1 914 -0.0008932574948235614\n", - "2 1404 0.0004232514430167562\n", - "3 1544 0.0011525606145957488\n", - "4 1545 0.0007839569686931374\n", - "5 1551 0.0010664550162285712\n", - "6 1556 0.0004030030702918709\n", - "7 1562 0.0013682239808026357\n", - "8 1565 0.001525718185249225\n", - "9 1568 0.0022582282008917287\n", + "Return mean Dataframe:\n", + "\n", + " asset returns\n", + "0 631 2.5793723583336672e-05\n", + "1 914 -0.0008932574948235617\n", + "2 1404 0.0004232514430167551\n", + "3 1544 0.0011525606145957497\n", + "4 1545 0.0007839569686931391\n", + "5 1551 0.0010664550162285764\n", + "6 1556 0.0004030030702918707\n", + "7 1562 0.001368223980802635\n", + "8 1565 0.0015257181852492213\n", + "9 1568 0.002258228200891721\n", "[3674 more rows]\n" ] } ], "source": [ - "replace_spec = {\n", - " 'node_csvdata': {\n", - " 'load': True\n", - " },\n", - " 'node_returnMean': {\n", - " 'save': True\n", - " }\n", - "}\n", + "replace = {'load_csv_data': {'load': True},\n", + " 'return_mean': {'save': True}}\n", + "\n", "\n", - "with warnings.catch_warnings():\n", - " warnings.simplefilter('ignore', category=UserWarning)\n", - " (returnmean_df,) = dff.run(task_list, outputs=['node_returnMean'], replace=replace_spec)\n", + "(return_mean_df, ) = task_graph.run(outputs=['return_mean'], replace=replace)\n", "\n", - "print('Return Mean Dataframe:\\n{}'.format(returnmean_df))" + "print('Return mean Dataframe:\\n')\n", + "print(return_mean_df)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Then we can load the `returnmean_df` from the saved file and evaluate only tasks that we are interested in." + "Now, we might want to load the `return_mean_df` from the saved file and evaluate only tasks that we are interested in.\n", + "\n", + "In the cells below, we compare different load approaches:\n", + "- in-memory,\n", + "- from disk, \n", + "- and not loading at all.\n", + "\n", + "When working interactively, or in situations requiring iterative and explorative task graphs, a significant amount of time is saved by just re-loading the data that do not require to be recalculated." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -651,61 +663,68 @@ "output_type": "stream", "text": [ "Using in-memory dataframes for load:\n", - "CPU times: user 48.6 ms, sys: 13.2 ms, total: 61.8 ms\n", - "Wall time: 363 ms\n", - "\n", - "Using cached dataframes on disk for load:\n", - "CPU times: user 58.5 ms, sys: 2.94 ms, total: 61.4 ms\n", - "Wall time: 121 ms\n", - "\n", - "Re-running dataframes calculations instead of using load:\n", - "CPU times: user 12.6 s, sys: 3.24 s, total: 15.8 s\n", - "Wall time: 46.7 s\n" + "CPU times: user 49.7 ms, sys: 4.22 ms, total: 54 ms\n", + "Wall time: 53.5 ms\n" ] } ], "source": [ - "warnings.simplefilter('ignore', category=UserWarning)\n", - "\n", + "%%time\n", "print('Using in-memory dataframes for load:')\n", - "replace_spec = {\n", - " 'node_csvdata': {\n", - " 'load': csvdata_df\n", - " },\n", - " 'node_returnMean': {\n", - " 'load': returnmean_df\n", - " }\n", - "}\n", "\n", - "%time out_tuple = dff.run(task_list, outputs=['node_outputCsv2'], replace=replace_spec)\n", - "\n", - "print('\\nUsing cached dataframes on disk for load:')\n", - "replace_spec = {\n", - " 'node_csvdata': {\n", - " 'load': True\n", - " },\n", - " 'node_returnMean': {\n", - " 'load': True\n", - " }\n", - "}\n", + "replace = {'load_csv_data': {'load': csv_data_df},\n", + " 'return_mean': {'load': return_mean_df}}\n", "\n", - "%time out_tuple = dff.run(task_list, outputs=['node_outputCsv2'], replace=replace_spec)\n", + "_ = task_graph.run(outputs=['output_csv_2'], replace=replace)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using cached dataframes on disk for load:\n", + "CPU times: user 55.4 ms, sys: 3.94 ms, total: 59.3 ms\n", + "Wall time: 58.4 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "print('Using cached dataframes on disk for load:')\n", "\n", - "print('\\nRe-running dataframes calculations instead of using load:')\n", - "replace_spec = {\n", - " 'node_csvdata': {\n", - " 'load': True\n", - " }\n", - "}\n", + "replace = {'load_csv_data': {'load': True},\n", + " 'return_mean': {'load': True}}\n", "\n", - "%time out_tuple = dff.run(task_list, outputs=['node_outputCsv2'], replace=replace_spec)" + "_ = task_graph.run(outputs=['output_csv_2'], replace=replace)" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 17, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Re-running dataframes calculations instead of using load:\n", + "CPU times: user 1.19 s, sys: 1.72 s, total: 2.91 s\n", + "Wall time: 3.02 s\n" + ] + } + ], "source": [ - "Above we are comparing the various load approaches: in-memory, from disk, and not loading at all. When working interactively, or in situations requiring iterative and explorative workflows, we save significant amount of time by just re-loading data we do not need to recalculate." + "%%time\n", + "print('Re-running dataframes calculations instead of using load:')\n", + "\n", + "replace = {'load_csv_data': {'load': True}}\n", + "\n", + "_ = task_graph.run(outputs=['output_csv_2'], replace=replace)" ] }, { @@ -717,54 +736,136 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 60.1 ms, sys: 6.02 ms, total: 66.1 ms\n", - "Wall time: 73.6 ms\n" + "CPU times: user 60.4 ms, sys: 55 µs, total: 60.5 ms\n", + "Wall time: 59.2 ms\n" ] } ], "source": [ - "loadsave_csvdata = \\\n", - " 'load' if os.path.isfile('./.cache/node_csvdata.hdf5') else 'save'\n", - "loadsave_returnmean = \\\n", - " 'load' if os.path.isfile('./.cache/node_returnMean.hdf5') else 'save'\n", + "%%time\n", + "import os\n", "\n", - "replace_spec = {\n", - " 'node_csvdata': {\n", - " loadsave_csvdata: True\n", - " },\n", - " 'node_returnMean': {\n", - " loadsave_returnmean: True\n", - " }\n", - "}\n", + "loadsave_csv_data = 'load' if os.path.isfile('./.cache/load_csv_data.hdf5') else 'save'\n", + "loadsave_return_mean = 'load' if os.path.isfile('./.cache/return_mean.hdf5') else 'save'\n", "\n", - "%time out_tuple = dff.run(task_list, outputs=['node_outputCsv2'], replace=replace_spec)\n" + "replace = {'load_csv_data': {loadsave_csv_data: True},\n", + " 'return_mean': {loadsave_return_mean: True}}\n", + "\n", + "_ = task_graph.run(outputs=['output_csv_2'], replace=replace)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Delete temporary files\n", + "\n", + "A few cells above, we generated a .yaml file containing the example task graph, and also a couple of CSV files.\n", + "\n", + "Let's keep our directory clean, and delete them." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ - "# Clean up\n", + "%%bash -s \"$task_graph_file_name\"\n", + "rm -f $1 symbol_returns.csv symbol_volume.csv # clean up" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "---\n", + "\n", + "## Node class example\n", + "\n", + "Implementing custom nodes in gQuant is very straighforward.\n", + "\n", + "Data scientists only need to override two methods in the parent class `Node`:\n", + "- `columns_setup`\n", + "- `process`\n", + "\n", + "`columns_setup` method is used to define the required column names and types for both input and output dataframes.\n", + "\n", + "`process` method takes input dataframes and computes the output dataframe. \n", + "\n", + "In this way, dataframes are strongly typed, and errors can be detected early before the time-consuming computation happens.\n", + "\n", + "Below, it can be observed `VolumeFilterNode` implementation details:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "class VolumeFilterNode(Node):\n", + "\n", + " def columns_setup(self):\n", + " self.required = {\"asset\": \"int64\",\n", + " \"volume\": \"float64\"}\n", + " self.addition = {\"mean_volume\": \"float64\"}\n", + "\n", + " def process(self, inputs):\n", + " \"\"\"\n", + " filter the dataframe based on the min and max values of the average\n", + " volume for each fo the assets.\n", + "\n", + " Arguments\n", + " -------\n", + " inputs: list\n", + " list of input dataframes.\n", + " Returns\n", + " -------\n", + " dataframe\n", + " \"\"\"\n", + "\n", + " input_df = inputs[0]\n", + " volume_df = input_df[['volume', \"asset\"]].groupby(\n", + " [\"asset\"]).mean().reset_index()\n", + " volume_df.columns = [\"asset\", 'mean_volume']\n", + " merged = input_df.merge(volume_df, on=\"asset\", how='left')\n", + " if 'min' in self.conf:\n", + " minVolume = self.conf['min']\n", + " merged = merged.query('mean_volume >= %f' % (minVolume))\n", + " if 'max' in self.conf:\n", + " maxVolume = self.conf['max']\n", + " merged = merged.query('mean_volume <= %f' % (maxVolume))\n", + " return merged\n", + "\n" + ] + } + ], + "source": [ + "import inspect\n", + "from gquant.plugin_nodes.transform import VolumeFilterNode\n", "\n", - "# Remove temporary workflow file.\n", - "os.unlink(wflow_file.name)" + "print(inspect.getsource(VolumeFilterNode))" ] } ], "metadata": { "kernelspec": { - "display_name": "py36-rapids", + "display_name": "Python 3", "language": "python", - "name": "py36-rapids" + "name": "python3" }, "language_info": { "codemirror_mode": { diff --git a/notebook/02_single_stock_trade.ipynb b/notebook/02_single_stock_trade.ipynb index b4da615c..a1a6313b 100644 --- a/notebook/02_single_stock_trade.ipynb +++ b/notebook/02_single_stock_trade.ipynb @@ -8,13 +8,6 @@ "First import all the necessary modules." ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": 1, @@ -27,7 +20,7 @@ "import warnings\n", "import ipywidgets as widgets\n", "import nxpd\n", - "import gquant.dataframe_flow as dff\n", + "from gquant.dataframe_flow import TaskGraph\n", "\n", "warnings.simplefilter(\"ignore\")" ] @@ -111,9 +104,8 @@ } ], "source": [ - "obj = dff.load_workflow('../task_example/simple_trade.yaml')\n", - "G = dff.viz_graph(obj)\n", - "nxpd.draw(G, show='ipynb')" + "task_graph = TaskGraph.load_taskgraph('../task_example/simple_trade.yaml')\n", + "nxpd.draw(task_graph.viz_graph(), show='ipynb')" ] }, { @@ -171,8 +163,8 @@ " \"type\": \"StockNameLoader\",\n", " \"conf\": {\"path\": \"./data/security_master.csv.gz\"},\n", " \"inputs\": []}\n", - "list_stocks = dff.run([node_stockSymbol],\n", - " outputs=['node_stockSymbol'])[0].to_pandas().set_index('asset_name').to_dict()['asset']" + "name_graph = TaskGraph([node_stockSymbol])\n", + "list_stocks = name_graph.run(outputs=['node_stockSymbol'])[0].to_pandas().set_index('asset_name').to_dict()['asset']" ] }, { @@ -198,7 +190,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "69388a913ab54af9a4b2ea7bcce7e8ed", + "model_id": "e84cd1b04f724ca99cc33f4e8bd8016d", "version_major": 2, "version_minor": 0 }, @@ -212,7 +204,7 @@ ], "source": [ "symbol = 'REXX'\n", - "o = dff.run(obj,\n", + "o = task_graph.run(\n", " outputs=['node_sharpeRatio', 'node_cumlativeReturn',\n", " 'node_barplot', 'node_lineplot', 'node_csvdata'],\n", " replace={'node_csvdata': {\"load\": True},\n", @@ -246,7 +238,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "78618cf4870b49c2a29058e23cbe8fa6", + "model_id": "03def0b8a60d4be3878882cd2015c860", "version_major": 2, "version_minor": 0 }, @@ -259,7 +251,7 @@ } ], "source": [ - "o = dff.run(obj,\n", + "o = task_graph.run(\n", " outputs=['node_sharpeRatio', 'node_cumlativeReturn',\n", " 'node_barplot', 'node_lineplot'],\n", " replace={'node_csvdata': {\"load\": cached_input},\n", @@ -278,7 +270,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d6e97f90036f4aacbb4e1998ae3e1515", + "model_id": "bec1cab73b8f40d58b9acbf5ac7187db", "version_major": 2, "version_minor": 0 }, @@ -309,7 +301,7 @@ " symbol = add_stock_selector.value\n", " para1 = para_selector.value[0]\n", " para2 = para_selector.value[1]\n", - " o = dff.run(obj,\n", + " o = task_graph.run(\n", " outputs=['node_sharpeRatio', 'node_cumlativeReturn',\n", " 'node_barplot', 'node_lineplot'],\n", " replace={'node_csvdata': {\"load\": cached_input},\n", @@ -333,6 +325,13 @@ "w" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/notebook/03_simple_dask_example.ipynb b/notebook/03_simple_dask_example.ipynb index 9e01a210..fc259fe8 100644 --- a/notebook/03_simple_dask_example.ipynb +++ b/notebook/03_simple_dask_example.ipynb @@ -2,21 +2,21 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import sys\n", "sys.path.append('..')\n", "\n", - "from gquant.dataframe_flow import run, load_workflow, viz_graph\n", + "from gquant.dataframe_flow import TaskGraph\n", "import nxpd\n", "from nxpd import draw" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -27,7 +27,7 @@ "\n", "

Client

\n", "\n", "\n", @@ -43,10 +43,10 @@ "" ], "text/plain": [ - "" + "" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -68,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -89,7 +89,7 @@ "" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -121,14 +121,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/conda/envs/rapids/lib/python3.6/site-packages/cudf-0.7.1-py3.6-linux-x86_64.egg/cudf/io/hdf.py:13: UserWarning: Using CPU via Pandas to read HDF dataset, this may be GPU accelerated in the future\n", + "/conda/envs/rapids/lib/python3.6/site-packages/cudf/io/hdf.py:13: UserWarning: Using CPU via Pandas to read HDF dataset, this may be GPU accelerated in the future\n", " warnings.warn(\"Using CPU via Pandas to read HDF dataset, this may \"\n" ] }, @@ -163,8 +163,8 @@ " \"type\": \"SortNode\",\n", " \"conf\": {\"keys\": ['asset', 'datetime']},\n", " \"inputs\": [\"node_csvdata\"]}\n", - "\n", - "df = run([node_csv, node_sort],\n", + "task_graph = TaskGraph([node_csv, node_sort])\n", + "df = task_graph.run(\n", " outputs=['node_sort'],\n", " replace={'node_csvdata': {\"load\": True}})[0]\n", "os.makedirs('many-small', exist_ok=True)\n", @@ -221,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -231,24 +231,23 @@ "" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "obj = load_workflow('../task_example/dask_task.yaml')\n", - "G = viz_graph(obj)\n", - "draw(G, show='ipynb')" + "task_graph = TaskGraph.load_taskgraph('../task_example/dask_task.yaml')\n", + "draw(task_graph.viz_graph(), show='ipynb')" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "df = run(obj, ['node_outputCsv'], {})[0]" + "df = task_graph.run(['node_outputCsv'], {})[0]" ] }, { diff --git a/notebook/04_portfolio_trade.ipynb b/notebook/04_portfolio_trade.ipynb index 118ed483..c98c0175 100644 --- a/notebook/04_portfolio_trade.ipynb +++ b/notebook/04_portfolio_trade.ipynb @@ -4,379 +4,341 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### gQuant – GPU Accelerated framework for Quantitative Analyst Tasks\n", - "### gQuant background\n", - "By definition, Quantitative finance is the use of mathematical models and large datasets to analyze financial markets and securities. It is one of the fields that requires massive computations to extract insight from the data. A lot of data science toolkits are developed to help data scientists to manipulate the data. It starts with scalar number computations at the beginning. Later, the development of Numpy library helps to operate the numbers at vectors. The popular Pandas library operates at a group of vectors (dataframe) level. The convenience of manipulating the data at a high level brings productivity gain for the data scientists in the quantitative finance. However, recently more and more data are collected. And more and more machine learning and statistics models are developed. This brings a few challenges that traditional data science library is hard to deal with:\n", + "# gQuant - Making Quantitative Analysis Faster\n", "\n", - "It is very time consuming for the CPU to crunch massive amount of data and compute the complicated data science models. \n", - "Large data set requires distributed computation, which is too complicated for data scientist to adopt. \n", - "The quantitative workflow becomes more complicated than before. It integrates massive data from different sources and requires a lot of iterations to find the best approach. \n", - "gQuant is developed to handle all these above challenges by organizing a group of dataframes in a graph. It introduces the idea of \"dataframe-flow\" that manipulate the data at the graph level. The dataframe manipulation is organized into an acyclic directed graph, where the nodes are dataframe processors and the edges are the directions of passing resulting dataframes. This graph approach organizes the quant's workflow at a high level that addresses the complicated workflow challenge. gQuant is built on top of the NVIDIA's RAPIDS library, which can passes GPU cuDF dataframes in the graph. In this way, all data are stored in the GPU memory and manipulated in the GPU. We can get orders of magnitude performance boosts compared to CPU. gQuant dataframe-flow is dataframe agnostic. Switching to dask_cudf dataframe, the computation automatically becomes multiple nodes and multiple GPUs distributed computation. \n", + "## Background\n", + "By definition, **Quantitative Finance** is the use of mathematical models and large datasets to analyze financial markets and securities, requiring massive computation to extract insight from the data. \n", "\n", - "In this blog, we will use a simple toy example to show how easy it is to accelerate the quant workflow in the GPU.\n", + "Many data science toolkits have been developed to help data scientists to manipulate the data. It starts with scalar number computations at the beginning. Later, the development of [Numpy](https://www.numpy.org) library helps to operate the numbers at vectors, and the popular [Pandas](https://pandas.pydata.org) library operates at a dataframe level. Manipulating data at a high level brings productivity gain for data scientists in quantitative finance.\n", "\n", - "### Environment Preparation" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "sys.path.append('..')\n", + "However, the amount of collected data is increasing exponentially over time. Also, more and more machine learning and statistical models are being developed. As a result, data scientists are facing new challenges hard to deal with traditional data science libraries.\n", "\n", - "import warnings\n", - "from gquant.dataframe_flow import run, load_workflow, viz_graph, Node\n", - "import nxpd\n", - "import ipywidgets as widgets\n", - "from nxpd import draw\n", - "import os\n", + "It is very time-consuming for CPUs to crunch massive amount of data and compute the complicated data science models. Large data set requires distributed computation, which is too complicated for data scientists to adopt.\n", "\n", - "warnings.simplefilter(\"ignore\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Start the Dask local cluster environment for distrubuted computation:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - "

Client

\n", - "\n", - "		\n", - "

Cluster

\n", - "
    \n", - "
  • Workers: 8
    • \n", - "
  • Cores: 8
    • \n", - "
  • Memory: 536.39 GB
    • \n", - "
\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from dask_cuda import LocalCUDACluster\n", - "cluster = LocalCUDACluster()\n", - "from dask.distributed import Client\n", - "client = Client(cluster)\n", - "client" + "As a consequence, the quantitative workflow has become more complicated than ever. It integrates massive data from different sources, requiring multiple iterations to obtain significative results. \n", + "\n", + "**gQuant** has been developed to address all these challenges by organizing dataframes into graphs. It introduces the idea of **dataframe-flow**, which manipulates dataframes at graph level. An **acyclic directed graph** is defined, where the nodes are dataframe processors and the edges are the directions of passing resulting dataframes.\n", + "\n", + "With a graph approach, quant's workflow is described at a high level, letting quant analysts address the complicated workflow challenge.\n", + "\n", + "It is GPU-accelerated by leveraging [RAPIDS.ai](https://rapids.ai) technology and has **Multi-GPU and Multi-Node support**.\n", + "\n", + "We can get orders of magnitude performance boosts compared to CPU. gQuant dataframe-flow is **dataframe agnostic**, and can flow:\n", + "- Pandas dataframe, computed in the CPU.\n", + "- cuDF dataframe, computed in the GPU and producing the same result but much faster.\n", + "- dask_cuDF dataframe, being the computation automatically executed on multiple nodes and multiple GPUs." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The Dask status page can be popped up in the brwoser by following javascript commands:" + "## Download example datasets\n", + "\n", + "Before getting started, let's download the example datasets if not present." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset is already present. No need to re-download it.\n" + ] } ], "source": [ - "from IPython.display import HTML\n", - "javascript = \"\"\"\n", - "\n", - "\"\"\"\n", - "HTML(javascript)" + "! ((test ! -f './data/stock_price_hist.csv.gz' || test ! -f './data/security_master.csv.gz') && \\\n", + " cd .. && bash download_data.sh) || echo \"Dataset is already present. No need to re-download it.\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Define some constants for the data filters. If using GPU of 32G memory, you can safely set the `min_volume` to 5.0" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "min_volume = 400.0\n", - "min_rate = -10.0\n", - "max_rate = 10.0" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### The toy example\n", - "To mimic the end-to-end quantitative analyst task, we are going to backtest a simple mean reversion trading strategy. The workflow includes following steps:\n", + "## The toy example\n", + "In this notebook, we will use a simple toy example to show how easy it is to accelerate the quant workflow in the GPU.\n", "\n", - "1. Load the 5000 end-of-day stocks CSV data into the dataframe\n", + "To mimic the end-to-end quantitative analyst task, we are going to backtest a simple mean reversion trading strategy.\n", "\n", - "2. Add rate of return feature to the dataframe.\n", + "The workflow includes following steps:\n", "\n", + "1. Load the 5000 end-of-day stocks CSV data into the dataframe.\n", + "2. Add rate of return feature to the dataframe.\n", "3. Clean up the data by removing low volume stocks and extreme rate of returns stocks.\n", - "\n", - "4. Compute the slow and fast exponential moving average and compute the trading signal based on it\n", - "\n", - "5. Run backtesting and compute the returns from this strategy for each of the days and stock symbols \n", - "\n", + "4. Compute the slow and fast exponential moving average and compute the trading signal based on it.\n", + "5. Run backtesting and compute the returns from this strategy for each of the days and stock symbols.\n", "6. Run a simple portfolio optimization by averaging the stocks together for each of the trading days.\n", + "7. Compute the sharpe ratio and cumulative return results.\n", "\n", - "7. Compute the sharpe ratio and cumulative return results\n", + "The whole workflow can be organized into a computation graph, which is described in a **yaml** file.\n", "\n", - "The whole workflow can be organized into a computation graph, which are fully described in a yaml file. Here is snippet of the yaml file:" + "Here is snippet of the yaml file:" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "- id: node_csvdata\n", + "- id: load_csv_data\n", " type: CsvStockLoader\n", " conf:\n", " path: ./data/stock_price_hist.csv.gz\n", " inputs: []\n", - "- id: node_sort\n", + "- id: sort\n", " type: SortNode\n", " conf:\n", " keys:\n", " - asset\n", " - datetime\n", " inputs:\n", - " - node_csvdata\n", - "- id: node_addReturn\n", + " - load_csv_data\n", + "- id: add_return\n", " type: ReturnFeatureNode\n", " conf: {}\n", " inputs:\n", - " - node_sort\n", - "- id: node_addIndicator\n", - " type: AssetIndicatorNode\n", - " conf: {}\n", - " inputs:\n", - " - node_addReturn\n", - "- id: node_volumeMean\n", - " type: AverageNode\n", - " conf:\n", - " column: volume\n", - " inputs: \n", - " - node_addIndicator\n" + " - sort\n", + "...\n" ] } ], "source": [ - "!head -n 29 ../task_example/port_trade.yaml" + "!head -n 18 ../task_example/port_trade.yaml\n", + "print(\"...\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Each nodes has a unique id, a node type, configuration parameters and input nodes ids. gQuant takes this yaml file, wires it into a graph to visualize it." + "Each node is composed of:\n", + "- a unique id,\n", + "- a node type, \n", + "- configuration parameters\n", + "- from zero to many input nodes ids.\n", + "\n", + "gQuant's `load_taskgraph` and `viz_graph` takes this yaml file, and wires it into a graph.\n", + "\n", + "We use nxpd's `draw` method to visualize it." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "" ] }, - "execution_count": 6, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "graph_obj = load_workflow('../task_example/port_trade.yaml')\n", - "G = viz_graph(graph_obj)\n", - "draw(G, show='ipynb')" + "import sys ; sys.path.append('..')\n", + "import nxpd\n", + "from gquant.dataframe_flow import TaskGraph\n", + "\n", + "task_graph = TaskGraph.load_taskgraph('../task_example/port_trade.yaml')\n", + "nxpd.draw(task_graph.viz_graph(), show='ipynb')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "From the graph, we notice that it is doing the 7 steps computation as we described above. \n", + "It can be observed that the graph above represents the computation steps described at the beginning of this section. \n", "\n", - "### gQuant Node implementation\n", - "In gQuant, we implement a few common nodes that is useful for the quantitative finance. With the help of Numba library, we implemented 36 technical indicators that are used in computing trading signals and accelerated in the GPU. However, it is not the gQuant's goal to be comprehensive for quant applications. It provides a framework that is easy for anyone to implement his own nodes in the gQuant. Data scientists just need to override two functions: \"process\" and \"columns_setup\" in the parent class \"Node\". The \"process\" function is the main function that takes input dataframes and computes the output dataframe. The \"columns_setup\" is to define what are the required input dataframe column names and types, what are the output dataframe column names and types after the computation. In this way, the dataframes are strongly typed and the errors can be detected early before the time consuming computation happens. Here is the code example for implementing MaxNode, which is to compute the maximum value for a specified column in the dataframe." + "## Node implementation\n", + "gQuant implementation includes some common nodes, useful for quantitative finance. With the help of [Numba](https://numba.pydata.org) library, we have implemented more than 30 technical indicators used in computing trading signals. All of them computed in the GPU.\n", + "\n", + "However, gQuant's goal is not to be comprehensive for quant applications. It provides a framework that is easy for anyone to implement his own nodes in the gQuant.\n", + "\n", + "Data scientists only need to override two methods in the parent class `Node`:\n", + "- `columns_setup`\n", + "- `process`\n", + "\n", + "`columns_setup` method is used to define the required column names and types for both input and output dataframes.\n", + "\n", + "`process` method takes input dataframes and computes the output dataframe. \n", + "\n", + "In this way, dataframes are strongly typed, and errors can be detected early before the time-consuming computation happens.\n", + "\n", + "Here is the code example for implementing `MaxNode`, which is to compute the maximum value for a specified column in the dataframe." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "class MaxNode(Node):\n", + "from gquant.dataframe_flow import Node\n", "\n", + "class MaxNode(Node):\n", + " def columns_setup(self):\n", + " \"\"\"\n", + " This method is used to define:\n", + " - required input dataframes column names and types,\n", + " - column names and types of the output dataframe.\n", + "\n", + " In this example, the input dataframe must have an `asset` column of type `int64`.\n", + "\n", + " The output dataframe will consist of two columns:\n", + " - The 1st column will be named with the value of the config parameter `@value`,\n", + " and its datatype will be `float64`.\n", + " - The 2nd column will be named `asset` and its datatype will be `int64`.\n", + " \"\"\"\n", + " self.required = {\"asset\": \"int64\"}\n", + " self.retention = {self.conf['column']: \"float64\",\n", + " \"asset\": \"int64\"} \n", + " \n", " def process(self, inputs):\n", + " \"\"\"\n", + " This method is used to calculate the maximum value of the `asset` column from the\n", + " input dataframe.\n", + "\n", + " The input and output dataframes structure are defined in the `columns_setup` method.\n", + " \"\"\"\n", " input_df = inputs[0]\n", " max_column = self.conf['column']\n", - " volume_df = input_df[[max_column,\n", - " \"asset\"]].groupby([\"asset\"]).max().reset_index()\n", + " volume_df = input_df[[max_column, \"asset\"]].groupby([\"asset\"]).max().reset_index()\n", " volume_df.columns = ['asset', max_column]\n", - " return volume_df\n", + " \n", + " return volume_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In case that there is no direct dataframe method for a particular logic, a Numba GPU kernel can be used to implement it. Some examples of customized GPU kernels in Numba can be found [here](https://github.com/rapidsai/gQuant/blob/master/notebook/05_customize_nodes.ipynb).\n", "\n", - " def columns_setup(self):\n", - " self.required = {\"asset\": \"int64\"}\n", - " self.retention = {\"@column\": \"float64\",\n", - " \"asset\": \"int64\"}" + "If we use customized GPU kernel functions inside the `process` method to process the dataframe instead of _normal_ dataframe API functions calls, we need to add `self.delayed_process = True` in the `columns_setup` method to let gQuant handle the dask graph integration problem. If we use _normal_ dataframe API functions inside the `process` method, nothing needs to be done as `self.delayed_process = False` by default.\n", + "\n", + "gQuant automatically handles the complication of including a customized GPU kernel node into the Dask computation graph." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "It is straightforward to customize one Node in the gQuant as shown in the example above. In case that there is no direct dataframe method for a particular logic, Numba GPU kernel can be used to implement it. gQuant can automatically handle the complication of include this customized GPU kernel node into Dask computation graph at the framework level.\n", + "## Running a task graph\n", + "gQuant graph is evaluated by specifying the output nodes and input nodes replacement." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import warnings; warnings.simplefilter(\"ignore\")\n", "\n", - "### gQuant Result and Benchmark\n", - "Similar to tensorflow, gQuant graph is evaluated by specifying the output nodes and input nodes replacement." + "# Define some constants for the data filters.\n", + "# If using a GPU of 32G memory, you can safely \n", + "# set the `min_volume` to 5.0\n", + "min_volume = 400.0\n", + "min_rate = -10.0\n", + "max_rate = 10.0" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "cumulative return 6815 22\n" + "CPU times: user 5.49 s, sys: 3.17 s, total: 8.66 s\n", + "Wall time: 9.06 s\n" ] } ], "source": [ - "action = \"load\" if os.path.isfile('./.cache/node_csvdata.hdf5') else \"save\"\n", - "o_gpu = run(graph_obj,\n", - " outputs=['node_sharpeRatio', 'node_cumlativeReturn',\n", - " 'node_csvdata', 'node_sort2'],\n", - " replace={'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", + "%%time\n", + "action = \"load\" if os.path.isfile('./.cache/load_csv_data.hdf5') else \"save\"\n", + "o_gpu = task_graph.run(\n", + " outputs=['sharpe_ratio', 'cumlative_return', 'load_csv_data', 'sort_2'],\n", + " replace={'filter_value': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", " {\"column\": \"returns_max\", \"max\": max_rate},\n", " {\"column\": \"returns_min\", \"min\": min_rate}]},\n", - " 'node_csvdata': {action: True}})\n", + " 'load_csv_data': {action: True}})\n", "\n", - "gpu_input_cached = o_gpu[2]\n", - "strategy_cached = o_gpu[3]" + "gpu_input_cached = o_gpu[2] # 'load_csv_data' node output\n", + "gpu_strategy_cached = o_gpu[3] # 'sort_2' node output" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The parameters for \"node_filterValue\" Node are overridden in the 'input_replace' arguments. The outputs from 4 nodes in the graph are computed and saved into 'o_gpu' variable. We cached the 'node_csvdata' and 'node_sort2' results in the the variables for later use. \n", + "In the example above, `filter_value` node parameters are overridden by the `replace` arguments.\n", "\n", - "After 'node_filterValue', the graph filter out the stocks that is not suitable for backtesting. Run following commands:" + "`o_gpu` will contain the outputs of four nodes: `sharpe_ratio`, `cumlative_return`, `load_csv_data`, `sort_2`.\n", + "\n", + "Similarly, the output from `load_csv_data` and `sort_2` nodes will be cached stored in `gpu_input_cached` and `strategy_cached` variables for later use. \n", + "\n", + "`filter_value` node configuration is set up to filter out the stocks that are not suitable for backtesting. It will discard stocks according to the values stored in `min_volume`, `min_rate`, and `max_rate` variables." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "5052\n", - "1558\n" + "5052 stocks in original dataset.\n", + "1558 stocks remaining after filtering.\n" ] } ], "source": [ - "print(len(gpu_input_cached['asset'].unique()))\n", - "print(len(strategy_cached['asset'].unique()))" + "print(\"{} stocks in original dataset.\".format(len(gpu_input_cached['asset'].unique())))\n", + "print(\"{} stocks remaining after filtering.\".format(len(gpu_strategy_cached['asset'].unique())))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "There are 5052 stocks loaded initially and 4598 stocks remaining after filtering. \n", - "\n", - "\"bqplot\" library is used to visualize the backtesting results in the JupyterLab notebooks. " + "[bqplot](https://github.com/bloomberg/bqplot) library is used to visualize the backtesting results in the JupyterLab notebooks. " ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a62a5d40fd9b4294ae1eeb67f6dc0103", + "model_id": "4f050abbdde44989a4a396d75d6c5316", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Figure(axes=[Axis(label='Cumulative return', orientation='vertical', scale=LinearScale(), side='left'), Axis(l…" + "Figure(axes=[Axis(label='Cumulative return', orientation='vertical', scale=LinearScale()), Axis(label='Time', …" ] }, "metadata": {}, @@ -385,18 +347,17 @@ ], "source": [ "# define the function to format the plots\n", - "def plot_figures(o):\n", + "def plot_figures(outputs):\n", " # format the figures\n", " figure_width = '1200px'\n", " figure_height = '400px'\n", - " sharpe_number = o[0]\n", - " cum_return = o[1]\n", + " sharpe_number = outputs[0]\n", + " cum_return = outputs[1]\n", " cum_return.layout.height = figure_height\n", " cum_return.layout.width = figure_width\n", " cum_return.title = 'P & L %.3f' % (sharpe_number)\n", " return cum_return\n", "\n", - "\n", "plot_figures(o_gpu)" ] }, @@ -404,7 +365,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This toy strategy gets a Sharpe ratio 1.6 without considering the transaction cost. Nice! \n", + "This toy strategy gets a Sharpe ratio 0.338 without considering the transaction cost. Nice! \n", "\n", "Next, we are going to compare the performance difference between CPU and GPU. The same computation graph can be used to flow the CPU Pandas dataframe with a few changes:\n", "\n", @@ -416,39 +377,43 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "5052\n", - "1558\n" + "CPU times: user 2min 38s, sys: 24.1 s, total: 3min 2s\n", + "Wall time: 3min 1s\n" ] } ], "source": [ - "print(len(gpu_input_cached['asset'].unique()))\n", - "print(len(strategy_cached['asset'].unique()))" + "%%time\n", + "o_cpu = task_graph.run(\n", + " outputs=['sharpe_ratio', 'cumlative_return', 'load_csv_data', 'sort_2'],\n", + " replace={'load_csv_data': {\"type\": \"PandasCsvStockLoader\"},\n", + " 'filter_value': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", + " {\"column\": \"returns_max\", \"max\": max_rate},\n", + " {\"column\": \"returns_min\", \"min\": min_rate}]},\n", + " 'add_return': {\"type\": \"CpuReturnFeatureNode\"},\n", + " 'add_indicator': {\"type\": \"CpuAssetIndicatorNode\"},\n", + " 'exp_strategy': {\"type\": \"CpuPortExpMovingAverageStrategyNode\"}})\n", + "\n", + "cpu_input_cached = o_cpu[2] # 'load_csv_data' node output\n", + "cpu_strategy_cached = o_cpu[3] # 'sort_2' node output" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cumulative return 6815 22\n" - ] - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "59bae21e36c64541b95fc4bfba160815", + "model_id": "0f42047d4eb74996a121e286e4c05514", "version_major": 2, "version_minor": 0 }, @@ -461,17 +426,6 @@ } ], "source": [ - "o_cpu = run(graph_obj,\n", - " outputs=['node_sharpeRatio', 'node_cumlativeReturn',\n", - " 'node_csvdata'],\n", - " replace={'node_csvdata': {\"type\": \"PandasCsvStockLoader\"},\n", - " 'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", - " {\"column\": \"returns_max\", \"max\": max_rate},\n", - " {\"column\": \"returns_min\", \"min\": min_rate}]},\n", - " 'node_addReturn': {\"type\": \"CpuReturnFeatureNode\"},\n", - " 'node_addIndicator': {\"type\": \"CpuAssetIndicatorNode\"},\n", - " 'node_exp_strategy': {\"type\": \"CpuPortExpMovingAverageStrategyNode\"}})\n", - "cpu_input_cached = o_cpu[2]\n", "plot_figures(o_cpu)" ] }, @@ -479,81 +433,116 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "It produces the exact same results as GPU version but much slower. All the above computation happens in the CPU Pandas Dataframe. To quantify the performance, we do the following experiment:" + "## Benchmarks\n", + "\n", + "While running this notebook, we have obtained the following results:\n", + "\n", + "- 181.00 seconds to run in CPU (Intel(R) Xeon(R) CPU E5-2698 v4 @ 2.20GHz).\n", + "- 9.06 seconds to run in GPU (NVIDIA v100).\n", + "\n", + "We get ~20x speed up by using GPU and GPU dataframes, compared to CPU and CPU dataframes.\n", + "\n", + "Note, the input nodes load the dataframes from the cache variables to save the disk IO time." ] }, { - "cell_type": "code", - "execution_count": 15, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cumulative return 6815 22\n", - "CPU times: user 29 s, sys: 4.85 s, total: 33.9 s\n", - "Wall time: 2.54 s\n" - ] - } - ], "source": [ - "%%time\n", - "o_gpu = run(graph_obj,\n", - " outputs=['node_sharpeRatio', 'node_cumlativeReturn'],\n", - " replace={'node_csvdata': {\"load\": gpu_input_cached},\n", - " 'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", - " {\"column\": \"returns_max\", \"max\": max_rate},\n", - " {\"column\": \"returns_min\", \"min\": min_rate}]}})" + "## Distributed computation\n", + "\n", + "Running this toy example in a Dask distributed environment is super easy, as gQuant operates at dataframe level.\n", + "\n", + "We mostly need to swap cuDF dataframes to **dask_cuDF** dataframes.\n", + "\n", + "Let's begin by starting the Dask local cluster environment for distributed computation.\n", + "\n", + "Dask provides a web-based dashboard to help to track progress, identify performance issues, and debug failures. To learn more about Dask dashboard, just follow this [link](https://distributed.dask.org/en/latest/web.html)." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 11, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "cumulative return 6815 22\n", - "CPU times: user 4min 19s, sys: 58.3 s, total: 5min 17s\n", - "Wall time: 1min 17s\n" - ] + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

Client

\n", + "\n", + "		\n", + "

Cluster

\n", + "
    \n", + "
  • Workers: 8
    • \n", + "
  • Cores: 8
    • \n", + "
  • Memory: 540.94 GB
    • \n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "%%time\n", - "o_cpu = run(graph_obj,\n", - " outputs=['node_sharpeRatio', 'node_cumlativeReturn'],\n", - " replace={'node_csvdata': {\"type\": \"PandasCsvStockLoader\",\n", - " \"load\": cpu_input_cached},\n", - " 'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", - " {\"column\": \"returns_max\", \"max\": max_rate},\n", - " {\"column\": \"returns_min\", \"min\": min_rate}]},\n", - " 'node_addReturn': {\"type\": \"CpuReturnFeatureNode\"},\n", - " 'node_addIndicator': {\"type\": \"CpuAssetIndicatorNode\"},\n", - " 'node_exp_strategy': {\"type\": \"CpuPortExpMovingAverageStrategyNode\"}})" + "# Start the Dask local cluster environment for distrubuted computation\n", + "from dask_cuda import LocalCUDACluster\n", + "from dask.distributed import Client\n", + "\n", + "cluster = LocalCUDACluster()\n", + "client = Client(cluster)\n", + "client" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We run this in V100 Tesla GPU and Intel(R) Xeon(R) Gold 6148 CPU. It takes 73 seconds to run in the CPU and 4 seconds to run in the GPU. We get 67x speed up by using GPU dataframe. Note, the input nodes load the dataframes from the cache variables to save the disk IO time. \n", + "Then, we will split the large dataframe into small pieces to be loaded by different workers in the cluster.\n", "\n", - "gQuant distributed computation\n", - "Run this toy example in Dask distributed environment is super easy as gQuant operates at the dataframe level. We just need to swap cudf Dataframe to dask_cudf Dataframe. First we split the large dataframe into small pieces to be loaded by different workers in the cluster (this step is noly need if the dataset is not prepared yet)" + "Notice this step is need only if the dataset is not split in multiple files yet." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['many-small/0.csv',\n", + " 'many-small/1.csv',\n", + " 'many-small/2.csv',\n", + " 'many-small/3.csv',\n", + " 'many-small/4.csv',\n", + " 'many-small/5.csv',\n", + " 'many-small/6.csv',\n", + " 'many-small/7.csv']" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import dask.dataframe as dd\n", "import os\n", + "\n", "os.makedirs('many-small', exist_ok=True)\n", "dd.from_pandas(cpu_input_cached.set_index('asset'), npartitions=8).reset_index().to_csv('many-small/*.csv', index=False)" ] @@ -567,64 +556,82 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "cumulative return 6815 22\n" + "CPU times: user 14 s, sys: 1.13 s, total: 15.1 s\n", + "Wall time: 1min 33s\n" ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "cdcb169b74db474e8bd1852a66f2ad7e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Figure(axes=[Axis(label='Cumulative return', orientation='vertical', scale=LinearScale()), Axis(label='Time', …" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "o_dask = run(graph_obj,\n", - " outputs=['node_sharpeRatio', 'node_cumlativeReturn'],\n", - " replace={'node_csvdata': {\"type\": \"DaskCsvStockLoader\",\n", + "%%time\n", + "o_dask = task_graph.run(\n", + " outputs=['sharpe_ratio', 'cumlative_return', 'load_csv_data', 'sort_2'],\n", + " replace={'load_csv_data': {\"type\": \"DaskCsvStockLoader\",\n", " \"conf\": {\"path\": \"many-small\"}},\n", - " 'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", - " {\"column\": \"returns_max\", \"max\": max_rate},\n", - " {\"column\": \"returns_min\", \"min\": min_rate}]}})\n", + " 'filter_value': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", + " {\"column\": \"returns_max\", \"max\": max_rate},\n", + " {\"column\": \"returns_min\", \"min\": min_rate}]}})\n", + "\n", + "dask_input_cached = o_dask[2] # 'load_csv_data' node output\n", + "dask_strategy_cached = o_dask[3] # 'sort_2' node output" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "#plot_figures(o_dask)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, it produces the same results. However, the performance is not better than in the other scenarios.\n", + "\n", + "Distributed computation only makes sense if we have a very large dataset that cannot be fit into one GPU.\n", "\n", - "plot_figures(o_dask)" + "In this example, the dataset is small enough to be loaded into a single GPU. The between-GPU communication overhead dominates in the computation.\n", + "\n", + "**Important:** Due to a bug in RAPIDS v0.8, distrubuted and single GPU results might differ (https://github.com/rapidsai/cudf/issues/2543).\n", + "\n", + "As a workaround, line #41 at `docker/build.sh` should be changed as follows:\n", + "```\n", + "CONTAINER=\"nvcr.io/nvidia/rapidsai/rapidsai:0.7-cuda${CONTAINER_VER}-runtime-ubuntu${OS_STR}-gcc7-py3.6\"\n", + "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Again, it produces the same results. However it is slow in the performance. Distributed computation only makes sense if we have a very large dataset that cannot be fit into one GPU. In this example, the dataset is small that can be loaded into on GPU. The between-GPU communication overhead dominates in the computation. We want to show that switching between single GPU vs distributed computation is very easy in gQuant.\n", + "## Strategy parameter search\n", + "Quantitative analysts often need to explore different parameters for their trading strategy.\n", "\n", - "### Strategy parameter search\n", - "Quantitative analyst usually need to explore different parameters for their trading strategy. The exploration process is an iterative process. gQuant help to speed up this by allowing using cached dataframe and evaluating the sub-graphs.\n", + "gQuant speeds up this iterative exploration process by using cached dataframes and sub-graphs evaluation.\n", "\n", - "To find the optimal parameters for this toy mean reversion strategy, we only need the dataframe from \"note_sort2\" node, which is cached in the \"strategy_cached\" variable. Because the GPU computation is so fast, we can make the parameter exploration interactive in the JupyterLab notebook:" + "To find the optimal parameters for this toy mean reversion strategy, we only need the dataframe from `sort_2` node, which is cached in the `gpu_strategy_cached` variable.\n", + "\n", + "Because the GPU computation is so fast, we can make the parameter exploration interactive in the JupyterLab notebook:" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9fce71658b9a484e810430895f397f1b", + "model_id": "2b5cd2a72ded4627b362b15051507f7d", "version_major": 2, "version_minor": 0 }, @@ -637,6 +644,8 @@ } ], "source": [ + "import ipywidgets as widgets\n", + "\n", "para_selector = widgets.IntRangeSlider(value=[10, 30],\n", " min=3,\n", " max=60,\n", @@ -652,14 +661,14 @@ " with out:\n", " para1 = para_selector.value[0]\n", " para2 = para_selector.value[1]\n", - " o = run(graph_obj,\n", - " outputs=['node_sharpeRatio', 'node_cumlativeReturn'],\n", - " replace={'node_sort2': {\"load\": strategy_cached},\n", - " 'node_exp_strategy': {'conf': {'fast': para1,\n", - " 'slow': para2}},\n", - " 'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", - " {\"column\": \"returns_max\", \"max\": max_rate},\n", - " {\"column\": \"returns_min\", \"min\": min_rate}]}})\n", + " o = task_graph.run(\n", + " outputs=['sharpe_ratio', 'cumlative_return'],\n", + " replace={'sort_2': {\"load\": gpu_strategy_cached},\n", + " 'exp_strategy': {'conf': {'fast': para1,\n", + " 'slow': para2}},\n", + " 'filter_value': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", + " {\"column\": \"returns_max\", \"max\": max_rate},\n", + " {\"column\": \"returns_min\", \"min\": min_rate}]}})\n", "\n", " figure_combo = plot_figures(o)\n", " w.children = (w.children[0], figure_combo,)\n", @@ -671,25 +680,6 @@ "w = widgets.VBox([selectors])\n", "w" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Conclusions\n", - "In this blog, we uses gQuant to do a simple trading strategy backtesting for 5000 stocks. This example shows that gQuant is designed to deal with the challenges that the data science is facing due to the large datasets and complicated data science models and workflows. Organizing the data at the graph level makes the workflow easy to understand and easy to maintain. We showed it is easy to implement a dataframe processing node in gQuant to adapt to any data science applications. We showed the dataframe agnostic feature of gQuant allows it to switch easily between cuDF, Pandas and Dask cuDf dataframes. The benefits of using GPU dataframe is huge compare to the CPU dataframe. In our toy example, we showed we can get 20x speed up. The more data are processed in the GPU, the more speed up we can get. The recent STAC A3 benchmark uses the similar GPU dataframe approach to do backtest in the GPU via customized Numba GPU kernels, achieving 6000x speedup.\n", - "\n", - "Hopefully you find this blog useful for your quant applications. We love to hear your feedbacks!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "out" - ] } ], "metadata": { diff --git a/notebook/05_customize_nodes.ipynb b/notebook/05_customize_nodes.ipynb index d92c67ea..83949f9f 100644 --- a/notebook/05_customize_nodes.ipynb +++ b/notebook/05_customize_nodes.ipynb @@ -17,9 +17,12 @@ "metadata": {}, "outputs": [], "source": [ + "import sys\n", + "sys.path.append('..')\n", + "\n", "# Load necessary Python modules\n", "import sys\n", - "from gquant.dataframe_flow import run, viz_graph, Node\n", + "from gquant.dataframe_flow import TaskGraph, Node\n", "import nxpd\n", "import cudf\n", "import numpy as np\n", @@ -121,7 +124,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "" ] @@ -145,8 +148,8 @@ " 'inputs': ['points']}\n", "\n", "task_list = [input_node, cudf_distance_node]\n", - "task_graph = viz_graph(task_list)\n", - "draw(task_graph, show='ipynb')" + "task_graph = TaskGraph(task_list)\n", + "draw(task_graph.viz_graph(), show='ipynb')" ] }, { @@ -165,23 +168,23 @@ "name": "stdout", "output_type": "stream", "text": [ - " x y distance_cudf\n", - "0 0.6723520442470782 0.9852608399140459 1.19281020873874\n", - "1 0.17910433988109542 0.5148459667925289 0.5451098367180478\n", - "2 0.5257041049202444 0.10985072301370735 0.5370586441689861\n", - "3 0.26735267785465155 0.5926111721129101 0.6501272611336109\n", - "4 0.9506848567426767 0.6139323276570774 1.1316866173028117\n", - "5 0.28852689302050794 0.5020580364068686 0.5790596168934493\n", - "6 0.5348492125065254 0.8500743192319166 1.004335615387833\n", - "7 0.6109030362226028 0.46907622241986024 0.7702175160989789\n", - "8 0.4527043048265347 0.6433244451659434 0.7866432033371579\n", - "9 0.04191743601279396 0.9407673034333391 0.941700690586517\n", + " x y distance_cudf\n", + "0 0.7010056431653792 0.5112436832006512 0.8676283855212867\n", + "1 0.0827499197410917 0.31152852238618334 0.32233145902514054\n", + "2 0.8178688604249669 0.185657535007264 0.8386764532033837\n", + "3 0.5426519412115872 0.6503820424613209 0.8470347870405698\n", + "4 0.47218390072374683 0.47004159313913396 0.6662557582366312\n", + "5 0.8292448348897857 0.019137123696438607 0.8294656265902529\n", + "6 0.43935774165080277 0.6747934476638714 0.8052213497905949\n", + "7 0.18490628874020032 0.9036444811295178 0.9223685184846183\n", + "8 0.57897057331248 0.29845019418994867 0.6513673642222182\n", + "9 0.5716020996317498 0.0982357346210656 0.5799820858095233\n", "[990 more rows]\n" ] } ], "source": [ - "(out_df,) = run(task_list, outputs=['distance_by_cudf'])\n", + "(out_df,) = task_graph.run(outputs=['distance_by_cudf'])\n", "print(out_df)" ] }, @@ -345,7 +348,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "" ] @@ -373,8 +376,8 @@ "task_list = [input_node, numba_distance_node,\n", " cupy_distance_node, cudf_distance_node]\n", "out_list = ['distance_by_numba', 'distance_by_cupy', 'distance_by_cudf']\n", - "task_graph = viz_graph(task_list)\n", - "draw(task_graph, show='ipynb')" + "task_graph = TaskGraph(task_list)\n", + "draw(task_graph.viz_graph(), show='ipynb')" ] }, { @@ -390,7 +393,7 @@ "metadata": {}, "outputs": [], "source": [ - "df_w_numba, df_w_cupy, df_w_cudf = run(task_list, out_list)" + "df_w_numba, df_w_cupy, df_w_cudf = task_graph.run(out_list)" ] }, { @@ -445,23 +448,23 @@ "\n", "

Client

\n", "\n", "\n", "\n", "

Cluster

\n", "
    \n", - "
  • Workers: 2
    • \n", - "
  • Cores: 2
    • \n", - "
  • Memory: 135.17 GB
    • \n", + "
  • Workers: 8
    • \n", + "
  • Cores: 8
    • \n", + "
  • Memory: 536.39 GB
    • \n", "
\n", "\n", "\n", "" ], "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -567,7 +570,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq8AAAD7CAYAAABE4X1VAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd1gU59o/8O8ifYGlSO8WlI4CggqiIqLRiGLLOTFGo7HkmJienPMmxrxJfjGJSU5OYmJLNGiKMVEUxYoFQUBQOmJBhaX3urRln98fvjsHpAgIzAL357r22mVmdubeYfbZ78zOPCtgjDEQQgghhBAyCCjxXQAhhBBCCCHdReGVEEIIIYQMGhReCSGEEELIoKHMdwGEEEKGl6qqKpSXl6OiogISiQQNDQ0AgMbGRkgkEgCAkpISRCJRm8eamprQ19eHnp4eVFVVeaufEMIvCq+EEEL6jFgsRmZmJnJyciAWi5GdnQ2xWIy8vDyUlpaioqICLS0tT7wcoVAIfX19mJiYwNLSEpaWlrC2toalpSVGjRoFe3t7aGho9MErIoQoGgH1NkAIIaSn6uvrcePGDcTHxyMtLQ3p6enIyMhAdXU1gIfhUh4m5beRI0dCT0+PO3qqr68PdXV1CIVCAICKigq0tLQAAC0tLdy8AHBHaeVHbMvLy1FeXo6CggKIxWIuKBcWFkImk0FJSQm2trZwdHSEg4MD3Nzc4O3tDWtr64FfWYSQPkXhlRBCyGOVlpbi/PnziIqKQlxcHJKTk9Hc3IyRI0fCxcUFDg4OcHJygoODA+zt7TFy5Ehe6mxubkZWVhYXptPT05Geno7MzExIpVKYmJjAy8sL3t7e8Pf3h7u7O5SU6PIPQgYTCq+EEELakclkuHr1Kk6fPo0zZ87gxo0bUFJSgoeHByZNmgQvLy94eXlh9OjRfJfaLXV1dbh+/Tri4uIQGxuLmJgYFBQUYOTIkZg1axZmz56Np556CsbGxnyXSgh5DAqvhBBCAPw3sB4+fBh//vkn8vPzMWrUKMyaNQuzZs1CQEAAdHV1+S6zz9y7dw/nz5/H+fPncerUKUgkEkyePBlLly7F8uXLYWJiwneJhJAOUHglhJBhLi8vD7t378ZPP/2E3NxcODo6YtmyZVi2bBnGjx/Pd3kDor6+HuHh4fjjjz9w4sQJNDU1ITAwEBs3bsTcuXPp1AJCFAiFV0IIGaYuXryIHTt24NixY9DX18eaNWvw7LPPwtHRke/SeFVXV4ewsDD8+OOPiIiIgLW1NdavX49169ZBX1+f7/IIGfYovBJCyDBz5swZ/O///i+uXr0KX19fbNy4EYsXL6a+Uztw+/Zt7Nq1C/v370dzczNefvllvPbaa7xdkEYIofBKCCHDxpUrV/D2228jNjYWc+fOxZYtW+Dt7c13WYNCbW0tvv/+e2zfvh319fV45ZVX8K9//Yvr5osQMnDoJB5CCBniiouLsWrVKvj5+UFbWxtxcXEIDw+n4NoDWlpaePvtt3H//n28//77+P7772Fvb48jR47wXRohww6FV0IIGcIOHjyI8ePH48KFCzh8+DDOnj2LSZMm8V3WoCUUCvH2228jMzMTM2bMwJIlSzB//nwUFxfzXRohwwaFV0IIGYIkEgnWrFmDlStXYuXKlbh58yYWL17Md1lDhrGxMX7++WdcunQJGRkZcHNzw8WLF/kui5BhgcIrIYQMMWKxGF5eXjh27BiOHTuGf//733RuZj+ZNm0aEhMTMXXqVAQEBODLL7/kuyRChjxlvgsghBDSd+7cuYOAgACIRCIkJibC0tKS75KGPJFIhMOHD+Prr7/Gm2++ifLycnzyySd8l0XIkEXhlRBChohbt25h+vTpsLa2xqlTp6Cnp8d3ScPKa6+9BgMDA6xZswYSiQRff/013yURMiRReCWEkCGgsrISQUFBsLGxwblz56ClpcV3ScPSypUroaGhgWeeeQbjxo3Dhg0b+C6JkCGHwishhAxyjDE8++yzqK2txcWLFwdNcK2trcWECRMwbtw4nDhxgu9y+szSpUtx8+ZNvPLKK3BycoKPjw/fJREypNAFW4QQMsgdPHgQZ86cwZEjR2Bqasp3Od3GGINMJoNMJnvieWlpaSlUSHz//fcxe/ZsvPjii2hubua7HEKGFPqFLUIIGcTq6+sxfvx4zJs3D99//z3f5fBGS0sLbm5uiIqK4rsUzv379+Hg4IDPPvsMr7zyCt/lEDJk0JFXQggZxPbs2YOKigps3bqV71LII2xtbfHKK6/gk08+gVQq5bscQoYMCq+EEDKI/f777wgODoaRkVGfz3v79u0QCAQQCASwsLBAfHw8/P39oa2tDU1NTcyYMQPR0dHtnldWVobXX38do0ePhqqqKvT09DB37tw2nfiHhoZy8xYIBGhoaOhw+IMHD7B8+XLo6urCwMAA8+fPR1ZWVrsa6+rqEB0dzT1PWfm/l3Q0NjZiy5YtGD9+PDQ1NaGvr4+nn34ax48fR0tLS5+vt9Y2bNiAkpIS+gEDQvoSI4QQMijl5uYygUDATp482a/LcXV1ZUKhkE2ePJldvXqV1dbWsvj4eObi4sJUVVXZpUuXuGkLCgqYra0tMzY2ZmFhYayqqordunWLBQcHM4FAwPbs2dNm3kFBQQwAq6+v73B4UFAQt8xz584xDQ0N5unp2a5GoVDIpk6d2mH9a9euZSKRiJ09e5ZJJBJWWFjI3nzzTQaAXbx48clX0GNMmjSJrVu3rt+XQ8hwQUdeCSFkkEpPTwdjDFOnTu33ZdXV1eH777/H5MmTIRQK4eHhgYMHD6KpqQmbN2/mpvvnP/+J+/fv49///jfmz58PHR0d2NnZ4ddff4WpqSleeeUVFBUVdXu5a9eu5ZY5a9YszJs3D/Hx8SgtLe32PCIiIuDo6IiAgABoaGjA2NgYX3zxBezs7Hq0DnprypQpSEtLG5BlETIcUHglhJBBKjc3F9ra2hCJRP2+LKFQCDc3tzbDnJ2dYWZmhuTkZBQUFAAAjh49CgCYN29em2nV1NTg7++P+vp6nDlzptvL9fT0bPO3/BfD8vPzuz2POXPm4OrVq1i3bh1iY2O5UwXkP+rQ3ywtLSEWi/t9OYQMFxReCSFkkKqqqoKOjs6ALEtXV7fD4fJzbYuLi9HY2Iiqqiqoq6tDW1u73bTGxsYAgMLCwm4v99FgrqqqCgA96l5rx44dCAkJwb179+Dv7w8dHR3MmTOHC9r9TSQSobKyckCWRchwQOGVEEIGKVNTUxQVFfX7RUfAw4uwWAc9KxYXFwN4GGLV1NQgEonQ0NCAmpqadtPKTxcwMTHp8/oEAkGX45577jmcP38elZWVCA0NBWMMwcHB+Oqrr/q8lkfl5+fD3Ny835dDyHBB4ZUQQgYpCwsLSKVS5OXl9fuyGhoaEB8f32ZYamoq8vPz4erqyv04wqJFiwAAJ0+ebDNtY2MjIiIioKGhgcDAwD6vT1NTE01NTdzf48aNw+7duwE8PGqcmZkJAFBRUUFAQADXq8GjdfaH7OxsWFhY9PtyCBkuKLwSQsggNXHiRGhpaSE8PLzflyUSifCvf/0LMTExqKurQ0JCAlasWAFVVVV888033HSffvopbG1t8eqrr+LEiROoqanB7du38fe//x0FBQX45ptvuNMH+tLEiRNx+/ZtiMVixMTE4N69e/D19eXGb9iwASkpKWhsbERxcTE+//xzMMYwc+bMPq+lNZlMhlOnTmHatGn9uhxChhV+OzsghBDyJJ555hk2ffr0fl2Gq6srMzc3ZxkZGSwwMJBpa2szDQ0N5ufnx6KiotpNX1payl599VVma2vLVFRUmEgkYoGBgSwiIoKb5ujRowxAm9uzzz7LYmJi2g3/n//5H8YYazd83rx53PwyMzOZr68vEwqFzNLSku3YsYMbl5SUxNavX8/s7e2ZpqYm09fXZ97e3mzPnj1MJpP145pj7NKlSwwAy8zM7NflEDKc0M/DEkLIIHb69Gk89dRTiIqKwpQpU/plGW5ubigtLUVubm6/zH8oCwwMRHV1NWJiYvguhZAhQ/nxkxBCCFFUc+bMQUBAAF5++WXEx8dDSYnOBlMUYWFhOHv2LCIjI/kuhZAhhVo5QggZ5L744gukpKRg+/btfJdC/k9xcTE2bdqE5cuXtzn3lhDy5Ci8EkLIIOfi4oLPP/8c//znP/v06vnt27dDIBAgOTkZeXl5EAgEeO+99/ps/kNVc3Mzli9fDiUlJXz33Xd8l0PIkEPnvBJCyBDx/PPP4/jx4zh16hS8vb35LmdYkkqlWLVqFY4dO4aYmBg4OTnxXRIhQw4deSWEkCFi165d8PX1RUBAACIiIvguZ9hpaGjAkiVLEBoaiqNHj1JwJaSfUHglhJAhQl1dHX/99ReCgoIwb948/Pjjj3yXNGzk5+dj9uzZiIyMxLlz5zBr1iy+SyJkyKLwSgghQ4iKigpCQkLwxhtvYN26dVixYkWHP9VK+s6ZM2fg5uaG4uJiREZGYvLkyXyXRMiQRuGVEEKGGCUlJXzyyScIDw/HuXPnMHHiRJw5c4bvsoacyspKbNq0CXPnzsXs2bORkJBApwoQMgAovBJCyBAVGBiIxMREuLi4YM6cOViyZAnEYjHfZQ16jDH8/PPPGDduHA4fPoyQkBAcPHgQWlpafJdGyLBA4ZUQQoYwMzMz/PXXX4iIiEBGRgbGjh2L9evXIz8/n+/SBqXz58/Dy8sLL7zwAgIDA5Geno4VK1bwXRYhwwqFV0IIGQZmzpyJGzdu4LPPPkNYWBjGjBmD1157DTk5OXyXpvBaWlpw5MgRTJw4EbNnz4a5uTlu3LiBkJAQjBw5ku/yCBl2qJ9XQggZZurr67Fnzx589tlnKCoqwrx587Bx40bMnj2bfl62lYKCAuzduxd79uxBXl4egoKCsGXLFri5ufFdGiHDGoVXQggZppqbm3H06FH88MMPuHz5MmxtbfG3v/0Ny5cvh7OzM9/l8aK2thZhYWE4dOgQwsPDIRKJsHr1aqxfvx6jR4/muzxCCCi8EkIIAXDz5k3s3bsXhw8fhlgshr29PZYtW4Z58+bB3d19SB+RLS0txblz53DkyBGcPHkSzc3NmDVrFp599lksWbIE6urqfJdICGmFwishhBAOYwwxMTHYv38/fv31V9TV1cHAwACzZs1CQEAAZsyYgVGjRvFd5hOpq6vDtWvXcO7cOZw9exaJiYkQCARwcHDAyy+/jODgYBgYGPBdJiGkE8p8F0AIIURxCAQCVFVVISwsDAYGBti3bx/EYjHOnj2Ll19+GfX19TAyMoKXlxe8vb3h5eUFV1dXhb1wqbm5Gbdv38b169cRGxuL2NhYpKamQiqVYsyYMZg9ezbef/99nDp1Crt370ZkZCSWLVvGd9mEkC7QkVdCCCEAHl7I9e677+Lbb7/FkiVLsHPnTujr63PjGxoacP36dcTFxSEmJgaxsbHIzc0FAIwcORJOTk6wt7eHg4MDrK2tYW1tDUtLS+jp6fVr3c3NzcjLy4NYLMaDBw9w9+5dZGRkICMjA3fu3EFzczPU1NQwceJELnRPnjwZVlZWbeZz9uxZrF69GsrKyti/fz9mzJjRr3UTQnqHwishhBAkJCRgxYoVKCwsxHfffdftvkvz8/ORnp7OhcWMjAxkZmaitLSUm0ZLSwtWVlYwMDCAvr4+9PX1oaenB319faiqqkIkEgF4+Mtg8sdNTU2oq6sDADQ2NkIikaCmpgYVFRUoLy9HeXk5KioqkJ+fj4KCAshkMgCAqqoqbGxs4OTkhPHjx3P3jo6OUFVVfezrKSkpwbp163Ds2DG8/PLL+Pzzz6GmptajdUkI6V8UXgkhZBhraWnB9u3bsWXLFvj6+mL//v2wsLB44vlKJBJkZ2cjJycHYrEYYrGYC5yt76VSKSoqKrhaqqurATwMoUKhEACgoaEBdXV1aGtrc6FXfm9iYgJLS0tYWlrC2toaJiYmEAgET1x/SEgINm3aBCsrKxw8eJC6xyJEgVB4JYSQYerBgwdYuXIl4uPjsXXrVrz11ltDuleBnnrw4AGef/55xMXF4cMPP6T1Q4iCoHchIYQMQyEhIXB2dkZ5eTliYmLwzjvvUDB7hI2NDS5cuIAPP/wQW7ZsQUBAAMRiMd9lETLsUUtFCCHDSElJCRYtWoRVq1bhhRdewPXr1+kr8S6MGDEC77zzDhISElBSUgJnZ2ccOHCA77IIGdYovBJCyDBx5swZuLm54caNG7hw4QK++eYbuhipm5ydnXHt2jVs2LABq1atwrJly1BeXs53WYQMSxReCSFkiKuvr8fmzZsxd+5cTJ06FUlJSZg+fTrfZQ066urq2LZtG06fPo2rV6/C0dERp06d4rssQoYdCq+EEDKExcfHw83NDT///DMOHDiAP/74o9/7XR3qAgICkJaWhpkzZ2LevHlYv349JBIJ32URMmxQeCWEkCFIKpXis88+w9SpU2FlZYW0tDQ8++yzfJc1ZOjq6uKXX37BoUOHcPjwYXh6eiIxMZHvsggZFii8EkLIEHP//n3MmDEDW7duxUcffYQzZ870Sd+tpL2lS5ciMTERhoaG8PLywtatW9HS0sJ3WYQMaRReCSFkCAkJCYGLiwsqKysRFxdHXWANAGtra1y4cAFffPEFPv30U0ybNg1ZWVl8l0XIkEUtGiGEDAHFxcVYuHBhmy6wXFxc+C5r2FBSUsLmzZuRkJCA2tpaTJw4Ebt37+a7LEKGJAqvhBAyyJ0+fRpubm5ISkrCxYsX8c0330BVVZXvsoYlZ2dnxMXFYePGjdi4cSOWLl2KsrIyvssiZEih8EoIIYOUvAusp556Cj4+PkhMTISfnx/fZQ178i61zpw5g9jYWDg5OSE8PJzvsggZMii8EkLIIHTt2jW4ubkhJCQEBw8epC6wFNCsWbOQmpoKf39/zJ8/n7rUIqSPUHglhJBBRN4Flo+PD6ytrZGWloa///3vfJdFOqGrq4uDBw9yXWp5eHjgxo0bfJdFyKBG4ZUQQgaJe/fuYfr06VwXWKdPn4a5uTnfZZFuWLp0KZKSkmBsbAxvb2/qUouQJ0DhlRBCBoGQkBC4urqiurqausAapKysrLgutbZt2wZfX1/qUouQXqCWjxBCFFhxcTEWLFiA1atX44UXXkBCQgJ1gTWICQQCrkstiURCXWoR0gsUXgkhREGdOnUKbm5uSE1NpS6whhgnJyfExsZyXWotWbKEutQipJsovBJCiIKRSCTtusCaNm0a32WRPibvUuvs2bOIi4uDo6MjTp48yXdZhCg8Cq+EEKJA4uLi4Obmhl9//RVHjhzBH3/8AV1dXb7LIv3I398faWlpCAgIwNNPP43169ejrq6O77IIUVgUXgkhRAFIpVJs3boVU6dOha2tLZKTk7Fo0SK+yyIDRCQS4cCBAzh06BD+/PNPeHp64vr163yXRYhCovBKCCE8y8zMxOTJk/H555/jyy+/xOnTp2FmZsZ3WYQHS5cuRWJiIkxMTKhLLUI6QeGVEEJ4whjD7t274eHhAYFAgMTERGzevBkCgYDv0giPrKysEBERge3bt2Pbtm3w8fHB3bt3+S6LEIVB4ZUQQnhQVFSEBQsW4KWXXsKmTZsQFRWFcePG8V0WURDyLrWuX7+OhoYG6lKLkFYovBJCyAA7cuQInJyckJaWhosXL2Lbtm3UBRbpkKOjI2JjY/HSSy9h48aNWLx4MUpLS/kuixBeUXglhJABUlNTg/Xr12Px4sWYO3cuUlNT4evry3dZRMGpqalh27ZtuHLlCpKSkuDk5ISwsDC+yyKENxReCSFkAMTGxmLixIk4evQojh49ipCQEGhpafFdFhlEpkyZghs3biAoKAhBQUHUpRYZtii8EkJIP5J3geXj44PRo0cjKSkJCxcu5LssMkiJRCLs2rWL61LLxcUFV69e5bssQgYUhVdCCOknN2/ehLe3N9cF1qlTp6gLLNInli5divT0dIwbNw5+fn5499130dzczHdZhAwICq+EENLH5F1geXp6QklJCUlJSdQFFulzJiYmOHnyJHbs2IFvv/0Wvr6+uHPnDt9lEdLvKLwSQkgfKioqwtNPP41//OMf2LRpE6Kjo2FnZ8d3WWSIEggEWLduHeLj49HU1AQ3Nzd88803fJdFSL+i8EoIIX3kr7/+gqOjIzIyMrgusFRUVPguiwwDDg4OiIuLw1tvvYU33ngDc+fORUFBAd9lEdIvKLwSQsgTqq6uxvr167FkyRI89dRTSElJgY+PD99lkWFGRUUFW7duRWRkJO7cuQM3NzccP36c77II6XMUXgkh5AnExMRg4sSJCA0NxbFjx6gLLMI7eZdaCxcuRFBQEFauXIna2lq+yyKkz1B4JYSQXmhubsbWrVvh6+uLsWPHIikpCQsWLOC7LEIAADo6Oti1axcOHz6M8PBwuLi4IDo6mu+yCOkTFF4JIeQRYWFhYIx1Oj4jI6NNF1jh4eEwNTUdwAoJ6Z4lS5YgLS0N9vb2mD59+mO71Lp27RoKCwsHsEJCeo7CKyGEtBIdHY1FixZhx44d7ca17gJLWVmZusAig4KJiQlOnDjBdanl4+OD27dvt5uupqYGS5cuxXPPPdflzhshfKPwSggh/6eyshLLly+HTCbDm2++iczMTG5cYWEh5s+fj3/84x94+eWXERUVRV1gkUFD3qVWQkICpFIp16VW65C6efNm5Ofn48KFC/j66695rJaQrgkY7V4RQggA4JlnnsFff/0FqVQKFRUVjB8/HgkJCTh+/Dg2bNgAkUiEkJAQTJ06le9SCek1qVSKjz/+GB9//DFmzZqFn376CfHx8W1+tlhFRQVxcXGYMGECj5US0jEKr4QQAmDfvn144YUX2gwbMWIEJk2ahNjYWGzYsAHbt2+HpqYmTxUS0reuXLnC9UQglUpRXV0NmUwGAFBWVoa5uTlSU1Ohra3Nc6WEtEXhlRAy7GVlZcHZ2Rn19fXtxgkEAnz66ad45513eKiMkP5VVVUFb29vZGVltbuQS1lZGc8//zz27t3LU3WEdIzOeSWEDGvNzc1YtmwZpFJph+OVlJTw3Xffobq6eoArI6T//frrr7h161aHPRBIpVL8+OOPOHToEA+VEdI5Cq+EkGHtvffeQ3JycqfdB7W0tKCoqAibN28e4MoI6V9ZWVl44403uuxZQCAQYO3atcjOzh7AygjpGp02QAgZts6fP4/Zs2d3u1ugI0eOYNGiRf1cFSH9TyqVYtKkSUhJSUFLS0uX06qoqMDT0xORkZEYMWLEAFVISOfoyCshZFgqLS3F3//+dygpdd0MqqqqAgA0NTVx6tSpgSiNkH4XHx+PhoYGtLS0YMSIEV2G0ubmZsTGxuLTTz8dwAoJ6RwdeSWEDEsLFizA6dOn250uMGLECDDGIJPJYGVlhYULF+Lpp5/GtGnTuCBLyFBRXFyMy5cv4/jx4zh+/Diqq6uhoqLS4Wk0SkpKiIqKwuTJk3molJD/ovBKCOlSTU0NpFIpGhsbIZFIwBhDZWUlN14ikaCxsbHD58pkMlRVVXU6b4FAAF1d3U7Ha2pqQk1NDcDDD06RSAQA0NbWhrKyMtTU1HrVddWOHTuwadMm7m/5h7VIJMKcOXPw1FNPYfbs2TAxMenxvAkZrFpaWhAXF4fTp0/jxIkTSEpKgkAggLKyMpqamqCkpAQzMzOkp6dDR0enV/OXX/hYWVkJxhhqa2u5oCxvYzoilUpRU1PT6bxbtxWPUldXh4aGBoCHO6fy2nV1dSEQCKClpQUVFZUevx7CHwqvhAwRdXV1KC8vR0VFBcrLy1FTU4O6ujpUV1dzjyUSCSoqKrjHNTU1qKqqgkQiQX19PRoaGlBfX//Y0KloWodg+QeRlpYWNDU1oaWlBV1dXWhqakIoFKKxsREhISGQSqUQCAQYNWoUJk+eDF9fX0yePBkGBgbQ19eHuro6z6+KEH7dvn0bJ0+exLlz5xAdHc0Fz4kTJ2LJkiWoqqpCdXU1amtrubamqqoKdXV1aGho4HZsuwqlikQecpWVlaGtrc21I3p6ehAKhdDS0oJQKISenh60tLS4v3V1daGtrQ0dHR3o6+tzbQidH9x/KLwSooCqqqpQUFCAkpISFBcXo6CgAOXl5W3C6aP3TU1N7eYjP8qgra3NhTddXV0IhUJoamq2GydvrIH/HpUQCoVQVVXtcByANsM7oqOj02kj3tTUhLq6ui7Xg7zT9NZHXuTD5YG79REd+bjq6mpIJBIusEskEtTW1iIxMRHAwz4sZTJZm6PIrWloaEBfXx96enod3o8cORImJiYwNDSEsbExTExMIBQKO30thPCpvr4ehYWFKCgoQHFxMfLz81FaWsq1K2VlZe0edxQP1NTUwBiDvr4+zM3Noa2tzYU4kUjE/a2hodEuDAKAnp4egP+2C62PmD7umxj5czvSuq14lPzbI+Dh+bu1tbVtvkGqrq5GS0sLF7bl7VJjYyPq6upQWVmJ2tpaLqR39HdHRCIRDAwMuDArv5c/NjU1hYmJCYyMjGBubt5lO0raovBKyAAqLCyEWCxGbm4ucnJyuGBaUlKCoqIiFBYWori4uM3X8AKBAIaGhjAwMOg0SHU0TEdHp9Ov0Yar5ubmDr8elEgkqK6u7nLn4NFhJSUlqKioaDMfTU1NmJiYwNjYGIaGhtxjExMTWFpawsrKChYWFjAwMBiol0yGOKlUiry8PGRnZyM7OxtisZhrS1oH1Ue/ch85ciRGjhzZLlC1ftw6eIlEIu60HaDz99JwVVtbi6qqqnY7AfLbozsGZWVlKC4ubhO45e2HqakpjIyMYGZmBiMjI67tkN+oXafwSkifaWhoQFZWFu7fv4/c3FyIxWKIxWLk5OQgNzcXubm5bUKpfI/bzMwMhoaGMDIy4hotQ0NDbrihoSGUlZV5fGWkM42NjSgpKUFhYSGKiopQUlLCBYbi4mJueGFhIcrKyrjnaWpqwtraGhYWFrCwsOA+lCwsLGBrawsbGxsKBgTAw5B4//59ZGVlITs7Gzk5OcjJyeHCan5+PtfVlZqaGszNzduFH/kRPmNjY24YXXzIv5aWFhQXF6OoqAj5+R/kR2oAACAASURBVPncjsajOx85OTltfv3P1NQU1tbWbQKtjY0NbGxsMHbs2GFxyhOFV0J6oKGhAfn5+UhPT0dGRgbu3bvH3R48eMDtRaurq8PMzAyjRo2Cqakp91j+t7W1NX1FNMw0NjYiLy8P+fn5KCgo4LYb+d9ZWVltvn40NTWFo6Mjt93Ib+PGjaNtZwiqqKjosF1JT09HQ0MDgLbtSuv2RD7M2tqazrMcoioqKtq1Ha3bj9afP3p6enBwcGjXfjg4OHAXrg12FF4J6UBZWRlSU1ORkZHB3d+8eRMlJSUAHp5LamlpiTFjxmD06NFt7keNGkXnPpJeqaiowL1793D37l1kZWW1uc/Pzwfw8DQSc3Nz2Nvbw8nJCQ4ODnB2doaDgwN3XiFRXGKxGKmpqUhJSUFKSgrS0tJw+/Zt7lsZAwMDjB07FmPHjoWdnR33eMyYMb26wp8MD/X19cjKysKdO3fa3G7fvo2CggIAD8/zt7W1hYuLC5ydneHs7AwXFxeMGjXqsf1dKxoKr2RYa2xsRHJyMpKTk5Geno60tDSkp6ejsLAQwMMLk5ycnODo6Ah7e3uMHTsWo0ePhq2tLX3tRgaURCJpE2YzMjKQlpaGjIwM7kpuGxsbODg4cNvshAkT4ODgQEfjeNDc3Izk5GQkJiYiJSWFC6zy86Stra25AGFvb88FVX19fZ4rJ0NNTU0NF2Zv3bqF1NRUJCcnIysrCzKZDEKhEE5OTlyodXNzg7u7e6+6IRwoFF7JsCGVSnHr1i1cv369za2hoQGqqqoYM2YM3N3d4ejoyH3lYmtry11VT4iiys/PR0ZGBve1c3p6OhITEyGRSKCiogIXFxdMnToV7u7ucHd3h729/aA70qLo8vPzuTYlOjoa0dHRqK+vh7a2Nuzs7ODg4MC1L66urjA0NOS7ZDLMNTU14c6dO7h+/TrXbiQkJKCwsBAjRozAuHHjuDbDx8cHEyZMUJh2g8IrGbLKysoQGRmJy5cv49q1a0hKSkJ9fT2EQiHc3Nzg6ekJDw8PeHh4wM7OjkIqGVKkUin3YRQfH4+EhASkpKRwP8bg7u6OyZMnw8/PD1OmTKFTXXpAJpMhKSkJERERuHLlCuLi4lBcXAxlZWW4uLjAy8uLu40bN47aFjKoZGdnIy4ujrvduHED9fX1EIlE8PT0xNSpU+Hv7w9vb2/eLiyl8EqGjPLyckRGRuLSpUu4ePEi0tLSAAAuLi6YMmUKF1Tpa1QyXMlPk0lISEBCQgKuXr2KW7duQUVFBZ6enpg+fTqmT59OYbYDd+7cQUREBCIiInDx4kWUlZXByMgIfn5+8Pb2xqRJk+Du7j5kLoghRK65uRkpKSlcmI2MjMSDBw8gFAoxbdo0+Pv7w9/fHy4uLgN2ZJbCKxm0ZDIZ4uPjcezYMZw6dQopKSkAAFdXV/j5+WHGjBnw9fXtsmNrQoa7/Px8XLp0CZcuXcLly5dx+/ZtqKioYNKkSZg3bx6CgoLg4ODAd5kDrrm5GRcvXsSRI0dw6tQp5OTkQEtLC35+ftyHtbOzMx1VJcNSVlYWtzN34cIFlJaWwtDQEAEBAQgODsbcuXP79ZxZCq9kUGloaMD58+dx/PhxhIWFobCwEKNGjcL8+fPh7+9PYZWQJ5Sfn4+LFy/iwoULOHHiBIqLizFmzBgEBQVhwYIFmDp16pD95qKhoQFnz57FX3/9hbCwMFRUVGDChAkICgqCv78/vLy8qP9dQh4hk8mQkpKCiIgIhIWFISoqCmpqaggMDERwcDDmz5/f5S+n9QaFV6LwZDIZzp07h59++gknT56ERCKBp6cn92Hq5OTEd4mEDEkymQyxsbE4fvw4jh07hszMTIwcORKLFy/GCy+8gEmTJvFdYp+IiorCrl27EBoaColEAm9vbwQHByM4OBi2trZ8l0fIoFJcXIzQ0FAcOXIEFy5cgEAgwOzZs7F+/XrMnTu3T3Z+KbwShZWdnY19+/Zh3759EIvF8PHxwYoVK/D000/D1NSU7/IIGXbu3LmD0NBQhISEIC0tDc7OzlizZg1WrFgx6H7ytrq6GgcPHsTOnTuRmpoKd3d3rF69GosWLYKZmRnf5REyJFRUVCAsLAwHDhxAREQELC0tsW7dOqxZswYmJia9ni+FV6Jwzp49i6+++grnzp2DkZERVq5ciTVr1sDOzo7v0ggh/ycuLg4//fQTfv/9dzQ2NmLRokV46623MHHiRL5L61J2djY+++wzHDhwADKZDM888ww2bNgAT09PvksjZEi7ffs2du/ejf3796O6uhrBwcH44IMPYG9v3/OZMUIURFhYGJs4cSIDwAICAtjRo0dZU1MT32VxfvvtNwaAAWBqamp8l9MtX3zxBVezubk53+X0ymBc78NJbW0t27dvH/feDQwMZHFxcXyX1U5BQQF78cUXmYqKCrOxsWH//ve/WUVFBd9lMcZoG+8PQ6Ht643ubEu///47c3V1Zerq6ty0qampA1ZjfX09CwkJYS4uLmzEiBFszZo1TCwW92geFF4J75KTk9mMGTOYQCBgwcHB7Pr163yX1CV/f/92jUJNTQ0bM2YMmzdvHk9VdV2Dq6vroG/AO1rvikAR/veK4vTp02zq1KlMIBCwZ555huXm5vJdEpNKpeyLL75gOjo6zMrKiu3du1ehdopbU9S2ZTAbCm1fb3TWXkZFRTGBQMDeeustVlNTw+7evcssLCwGNLzKtbS0sAMHDjBbW1umoaHB3nrrLVZbW9ut5yrGTyWQYUkqleKDDz6Ah4cH6uvrER0djb/++kvhv3bsCGMMMpkMMpms1/PQ0tKCj48PrzX01pPWPpj15Xof7OsxMDAQUVFROHLkCK5fvw5HR0fs3buXt3qysrLg6+uL999/H6+//joyMzOxZs2aQdVjgCK0LWToOHz4MBhj2Lx5M7S0tDB69GiIxWJeLnxWUlLCihUrkJmZic8++ww//fQTJkyYgLi4uMc+V3kA6iOknbKyMixbtgyxsbHYvn07Nm3apDA/O9cb2trayMrKGvY1DEe03ttbuHAhAgMDsWXLFqxfvx7R0dHYuXMn1NTUBqyGyMhIBAcHw8rKCgkJCXB0dBywZfcl2r5IXxKLxQCgUBdYqqqq4uWXX8aSJUvwwgsvwM/PD3v37sWKFSs6fQ6FVzLgSktLMWPGDFRWViIyMhLu7u58l0QI6WMaGhr44osv4O/vj7/97W/Iy8tDWFjYgATYS5cuYe7cuXjqqadw4MCBfu0snZDBpKWlhe8SOmVqaorw8HB8+OGHWLlyJRoaGrB27doOpx28h7rIoCSVSrFgwQLU19cjNjZWoYNrZmYmFi5cCJFIBKFQCF9fX0RFRbWbLjQ0FAKBgLs1NDRw4xobG7FlyxaMHz8empqa0NfXx9NPP43jx49zjcj27dshEAhQV1eH6Ohobj7Kysodzv/WrVtYtmwZDAwMuGF79+7ttIZHX9O8efMgEomgqamJGTNmIDo6mhv/8ccfc/No/TXj6dOnueEjR47khj+udrmSkhK88sorsLGxgaqqKgwNDREcHIykpKRer/fuktcoEAhgYWGB+Ph4+Pv7Q1tbu8N1IFdWVobXX38do0ePhqqqKvT09DB37lxcvHiRm6az//2jwx88eIDly5dDV1cXBgYGmD9/fpujad1Zj93ZlhTRnDlzcP78eVy7dg0bNmzo9+Xl5ORg4cKFWLBgAQ4fPqyQwVVR2hbgYZt86NAhBAQEwMTEBBoaGnB2dsY333zT5lSFnm7Tcq3fR2pqarCwsMCsWbOwf/9+1NfXt5m2J+1Eb9Z5Z21fZWVlm9cmEAjw8ccfc+un9fAlS5b0eNndWQc9bXtbv66ebEvHjh0D8HDnUiAQwNvbu8evpz8JBAJs3boV77//PjZu3Nh5299/p+IS0t4XX3zBNDQ0WEZGBt+ldOnOnTtMV1eXmZubs7Nnz7KamhqWkpLCZs+ezWxsbDo8ET4oKIgBYPX19dywtWvXMpFIxM6ePcskEgkrLCxkb775JgPALl682Ob5QqGQTZ06tdOa5PP38/NjFy9eZHV1dSw2NpaNGDGClZSUdFoDYw8vWhCJRGzGjBksKiqK1dTUsPj4eObi4sJUVVXZpUuXulWLu7s7MzAwaDe8q9rz8/OZtbU1MzY2ZidPnmQ1NTUsLS2N+fn5MXV1dXb16lVu2t6s9+5ydXVlQqGQTZ48mV29epXV1tZ2ug4KCgqYra0tMzY2ZmFhYayqqordunWLBQcHM4FAwPbs2dNm3p2td/nwoKAgbpnnzp1jGhoazNPTs0frsSfbkiIKCwtjAoGAnTx5sl+Xs3DhQmZvb88aGhr6dTm9pWhtS1hYGAPA/t//+3+svLyclZSUsP/85z9MSUmJvfnmm53W0p1tWv4+MjExYWFhYay6upoVFhayjz76iAFgX3/9NTdtT9qJnuhJ2xcYGMiUlJTY3bt3281n8uTJ7Jdffunx8nuyDhjrWdvbV9uSopo3bx4bP348k0ql7cZReCUDRiqVMktLS/b222/zXcpjLV26lAFgf/75Z5vheXl5TE1NrduNgq2tLZsyZUq7ae3s7HodXsPDwx87TUfhFQCLiYlpMzwlJYUBYK6urt2qpTfh9fnnn2cA2jX8BQUFTE1Njbm7u3PDerPeu0u+DhITE9sM72gdrFq1igFgv/32W5tpGxoamJmZGdPQ0GCFhYXc8MeF17CwsDbDlyxZwgBwOx1yXa3HnmxLimr+/PnM39+/3+b/4MEDpqSkxEJDQ/ttGU9K0dqWsLAwNn369HbDV6xYwVRUVFhVVVWHtXRnm5a/jw4dOtRu/nPmzGkT3HrSTvRET9q+M2fOMADspZdeajNtVFQUMzc371UvFT1ZB4z1rO3tq21JUd2+fZsJBAJ26tSpduMovJIBc+vWLQZA4bvCYowxbW1tBoDV1NS0G+fs7NztRmHjxo0MAHvxxRdZTExMh3uQct0Nr6WlpY+dpqPwqq6uzmQyWbvnmJmZMQAsPz//sbX0JryKRCKmpKTU7kOQMcb1DSrv468367275EdeO/LoOhCJRAwAq66ubjftc889xwCwn3/+mRv2uPDaOugyxthrr73GALDk5OQ2w7tajz3ZlhTVgQMHmKqqar/V/ssvvzA1NTXW3NzcL/PvC4rYtnRE3k/qo0c8e7JNd/U+elRP2ome6Gnb5+zszDQ1Ndu0s0FBQWzbtm09XjZjPVsHjPWs7e2rbUmRubi4sH/961/thtM5r2TAlJeXAwAMDQ15rqRrjY2NqKmpgbq6OrS0tNqNNzIy6va8duzYgZCQENy7dw/+/v7Q0dHBnDlzcPTo0V7XJxQKe/U8+Tmyj5K/nuLi4l7X1JnGxkZUVVVBJpNBJBK1O6/sxo0bAB7+7GhfrvfO6Orqdji89TqQ16yurg5tbe120xobGwMACgsLu71ckUjU5m9VVVUA6FH3R/2xLQ00IyMjNDU1oaampl/mX1FRAZFI1O6ca0WhiG1LVVUVtmzZAmdnZ+jp6XHvzbfeegsAIJFIOnze47bpx72PWutJO9EbPWn7Xn31VUgkEnz//fcAHv4q1IULF7Bu3boeL7cn66A38+7v9lIRjBw5EmVlZe2GU3glA8bGxgYAkJ6ezm8hj6GmpgZtbW00NDSgtra23Xh5CO8OgUCA5557DufPn0dlZSVCQ0PBGENwcDC++uqrdtP2p6qqqg6Hyxvu1o2dkpISmpqa2k1bWVnZ4Tw6q11NTQ26urpQVlZGc3Mz2MNve9rdZsyY0afrvTNlZWVgHfwidut1oKamBpFIhIaGhg5DVlFREQA80e9yd6arbaAn25KiSktLg76+fqc7EU/K2toaJSUlKC0t7Zf5PylFbFuefvppfPTRR3jxxRdx+/ZtyGQyMMbw9ddfA0CH75fueNz76NFpu9tO9EZP2r5nn30WxsbG+O6779DY2Igvv/wSzz//PPT09Hq83J6sA7nutr0D0V7yTSaTITMzE7a2tu3GUXglA8bExAS+vr749ttv+S7lsebOnQvg4ZWerZWWluLWrVvdno+uri4yMzMBACoqKggICOCu+jx58mSbaTU1Nds0WuPGjcPu3bt7+xLaqa2tRXJycpthqampyM/Ph6urK0xNTbnhpqamyMvLazNtYWEhcnJyOpx3V7UHBwdDKpV2eEX/Z599BisrK0ilUgB9t94709DQgPj4+DbDOloHixYtAoB2/6PGxkZERERAQ0MDgYGBT1zPo7pajz3ZlhRRY2Mjdu3ahWXLlvXbMmbOnAkdHZ0+fd/0NUVqW1paWhAdHQ0TExO88sorMDQ05ILuoz0B9Ib8fRQeHt5u3IQJE/Daa69xf/ekneipnrR9ampqeOmll1BcXIwvv/wSv/zyCzZv3tyr5QI9WwdAz9re/m4v+RYWFoaCggJuHbbR7ycsENLKxYsXmZKSEtu7dy/fpXTp7t27TF9fv81VnOnp6SwwMJAZGRl1+1wikUjE/Pz8WHJyMmtoaGBFRUVs69atDAD7+OOP2zx/zpw5TCQSsZycHHb16lWmrKzcpleG7pyr1NU5r0KhkPn4+LDY2Ngur7RnjLFNmzYxAOzbb7/lfkJw2bJlzNzcvMNzXruqvaioiI0ePZqNGjWKhYeHs8rKSlZWVsZ27tzJNDU121zI0Jv13l3yq479/f173NtAdXV1m94Gdu/e3a313tnwd955p8OLx7pajz3ZlhTRq6++yrS1tdn9+/f7dTkfffQR09TUVNgeTRStbZk5cyYDwD7//HNWUlLCJBIJu3DhArOysmIA2Llz5x5bC2Mdb9Py95GpqSk7ceIEq66uZmKxmG3cuJEZGxuz7OxsbtqetBM90dO2jzHGSkpKmIaGBhMIBCwoKKhXy5XryTpgrGdtb19tS4qotLSUWVlZsb/97W8djqfwSgbce++9x5SVldkff/zBdyldunXrFlu4cCHT0dHhuoE5ceIE8/f3ZwAYALZmzRp29OhR7m/57dlnn2WMMZaUlMTWr1/P7O3tmaamJtPX12fe3t5sz5497S4gyMzMZL6+vkwoFDJLS0u2Y8cOxhhjMTEx7eb/6H5nZzXIL7oAwMzNzdm1a9fYjBkzmJaWFtPQ0GB+fn4sKiqq3WuvrKxka9euZaampkxDQ4P5+Piw+Ph45u7uzs3vnXfeeWztcmVlZez1119no0aNYioqKszQ0JDNnj273QdjT9Z7T8l/4zwjI4MFBgYybW3tLtdBaWkpe/XVV5mtrS1TUVFhIpGIBQYGsoiIiMeu947+Z//zP//DGGPthrf+zfqu1mNPtiVF89FHHzElJSX266+/9vuympqa2JQpU5iVlRV78OBBvy+vNxSlbWHsYVBbv349s7S0ZCoqKszY2JitWrWKvfvuu9wy3d3de71NP/o+MjU1Zc888wy7fft2u/XSk3bicXrb9sm9+OKLDAC7fPlyj5f9qJ6sg562vU+yLaGDXhgUQVVVFfPy8mI2NjasuLi4w2kEjPXyhBZCnsBrr72G//znP/jggw/w3nvvDeqfhiWDg5ubG0pLS5Gbm8t3KcOGRCLBSy+9hIMHD+K7774bkB8pAB6e7zdz5kwUFRUhNDQUXl5eA7JcMnTs27cPO3bsQEJCAt+lDCv37t3DggULUF5ejkuXLsHOzq7D6SgxEF58/fXX+O677/DJJ5/A19cXN2/e5LskQkgfioyMhKurK44fP44TJ04MWHAFAH19fURGRmLChAnw9fXFRx991OvzJcnwtHPnTrz++ut8lzGs7Nu3DxMmTICKigri4uI6Da4AhVfCo40bN+L69euQSqVwdXXF+vXruSu5CSGDU05ODlauXInp06fDzs4OKSkpmDNnzoDXoaOjg5MnT+K7777Dtm3b4Ojo2OFFM4QAwN69e7Fo0SLU1tZi586dqKio6NeLC8l/xcTEwM/PD2vWrMEzzzyD6OhoWFpadvkcCq+EV05OToiJicHevXsRFhaGMWPGYPPmze2utiTkUY/2BdnRbevWrdzvuycnJyMvLw8CgQDvvfce3+UPOVlZWdi8eTPs7Oxw7do1HDp0CCdPnoSFhQVvNQkEAqxbtw4pKSlwdXXFvHnz4OPjgwsXLvBWE3ky3X3f90ZoaCj09PTwww8/4Pfff++0v+D+rGE4uXnzJpYtW4YpU6ZAVVUV8fHx2LVrFzQ1NR/7XDrnlSgM+R7vV199hfLycixatAhr1qzBzJkz6ZxYQhRQU1MTjh07hp9++glnz56FnZ0d3nnnHaxYsUIhfyjg0qVL+OCDDxAZGYkpU6Zg/fr1WLZsGdTV1fkujZBhoaWlBadOncLOnTtx6tQpTJgwAdu2bcOsWbN6NB8Kr0ThNDQ04LfffsOPP/6I6Oho2NjYYPXq1Vi9evVjv0oghPS/tLQ0/Pjjjzh48CAqKiowZ84crF27FgsWLBgUO5qXL1/Gjh07EBoaCm1tbaxatQrr1q3DuHHj+C6NkCGpoKAAP/74I/bs2QOxWAx/f3+89NJLWLhwYa9+oIfCK1FoN2/exE8//YQDBw6gpKQE06ZNQ1BQEBYsWIBRo0bxXR4hw0ZSUhKOHz+O0NBQJCYmYsyYMVi9ejWef/55mJub811erxQWFnIfqDk5OZgyZQoWL16M4OBgWFtb810eIYNaaWkpQkNDceTIEZw/fx4ikYjbURw7duwTzZvCKxkUmpubcfLkSfz5558IDw9HRUUFnJ2dsWDBAgQFBcHDw6Pff16VkOGkubkZly9fxvHjx3H8+HFkZ2fD3NwcCxYswPLlyzFt2rQh856TyWQ4ffo0fvvtN5w4cQKVlZXw8PBAcHAwFi9e3OVVz4SQ/8rPz8fRo0dx5MgRXL58Gaqqqpg9ezaWLVuGxYsXQ01NrU+WQ+GVDDpSqRSRkZHch+r9+/dhYmKCGTNmYPr06fDz86Ov/wjpoZaWFiQnJ+PSpUu4dOkSIiMjUVVVBRcXF24n0d3dfcgE1s40NTXhwoULOHLkCEJDQ1FSUoLx48dj1qxZ8Pf3x/Tp06Grq8t3mYQoBIlEgujoaERERCAiIgI3btyAUCjEU089hcWLF2Pu3LnQ0tLq8+VSeCWDXkpKCsLDw3H58mVERUWhtrYWpqamXJD18/PD+PHj+S6TEIXyaFi9cuUKKisrMXLkSEybNg0zZszAvHnzYGtry3epvGlpacGVK1cQHh6OCxcuIDExEQKBAO7u7pg5cyb8/f0xdepUaGho8F0qIQNCKpUiPj6eC6sxMTFobGzE+PHj4e/vj8DAQAQEBPT7RZAUXsmQ0tLSgqSkJERFRSE6Ohrnzp1DZWUldHR04OzsDHd3d+7m6OjId7mEDJj8/Hxcv36du0VHR6OiogKGhobw8vKCj48PZs2ahQkTJgyKi674UFNTg7i4OJw/fx7nz5/HjRs3MGLECNjZ2cHd3R0+Pj6YOnUq7O3taR2SIaF1uxEdHY2rV69CIpHA2NgY06ZNw6xZsxAYGDjg54hTeCVDmlQqxfXr13Ht2jXEx8cjISEBt27dgkwmg6mpKTw8PODh4YGJEyfC0dERNjY2Q/5rUTK0SaVS3L17F2lpabhx4wa33VdWVkJFRQXOzs7w9PSEh4cHvL294ejoSNt8L4nFYly5cgVxcXG4du0aEhMT0djYCH19fXh5ecHLywseHh5wdnaGlZUV3+US0qXi4mKkpKTgxo0biI2NxbVr15CXl4cRI0bA0dERXl5e8Pb2xpQpU3j/NpPCKxl2qqurcePGDSQkJCA+Ph7x8fG4f/8+AEBLSwv29vZwcnKCg4MDnJ2d4eDgQF10EYUjk8lw7949pKWlISMjg7u/efMmmpqaMGLECIwbNw4eHh7w9PSEp6cnXF1dqU/TftTU1ITExETExcVxgfbu3bsAAF1dXTg7O8PZ2RkuLi5wcXGBk5MTtLW1ea6aDDcNDQ3IyMhASkoKUlNTuXv5L1yamZlxO1/e3t5wd3fvl/NWnwSFV0IAVFVVcQEgPT2duxUUFAAARCIRxo8fjzFjxrS7jRw5kufqyVCWl5eHu3fvIisrC3fv3uVumZmZqK+vh0AggI2NDRwcHODk5ARHR0c4OjrC3t6ezsVUAFVVVUhNTW0TElJTU1FdXQ2BQABbW1uMGzcOdnZ2sLOzw9ixYzF27FhYWVnRqQfkieTn5+P27du4c+cOd7t58ybu3r2LlpYWaGhowNHRsc1OlbOzM4yMjPgu/bEovBLShfLy8jZHtOQh4v79+2hqagLwMNjKg+zo0aMxatQoWFhYwNLSElZWVgq3x0oUS3l5OXJzc5GTkwOxWIx79+61Car19fUAAE1NTYwePZrb1saPH899Q0Db2ODz4MEDLsjeunWLCxllZWUAADU1NYwZMwZjx46FnZ0dRo8eDSsrK1hZWcHGxqZbP6FJhrbGxkbk5ORwt6ysrDZBtba2FgCgra3N7RjZ2dnByckJLi4uGDNmDEaMGMHzq+gdCq+E9EJLSwvEYnGbI2Ly+/v373ONBvDw60ILCwtYW1vD3Nyce2xhYQETExMYGRnR0dshSCaTobi4GCUlJcjLy0Nubi5yc3ORnZ3N/Z2dnQ2JRMI9R19fH7a2ttyOUOt7MzMzHl8NGSjl5eVckG19f+/ePVRVVXHTGRgYcGHW2toa1tbWsLS0hIWFBczNzWFsbNxnfWqSgdfc3Izi4mIUFBQgLy8P2dnZyM7O5nZyc3JyuG8GAUBDQwOjR4/mjty3DqsmJiY8vpL+QeGVkH5QWVnJhRN5aJE3Orm5uRCLxWhoaOCmV1FRgZGREYyNjblAa2JiAmNjYxgZGcHU1BQGBgbQ09ODvr4+hEIhj69u+KqurkZ5eTkqKipQXFzM3fLz81FSUoKioiIUFBSgpKQExcXFkMlk3HO1tLRgZWXFBQz5kXkLCwtuh4aOppGuVFVVIScnp02Qkd8ePHiAwsLCNtucZZs2gAAAIABJREFUnp4eTE1NYWxsDDMzMxgZGcHc3JxrU4yMjKCvrw99fX3a9gZAY2MjysvLUVZWhrKyMuTn53NtRmFhIQoLC1FQUIDi4mLu/FM5Y2Njbmfl0R0WKysrGBoa8vSq+EHhlRCeyIOPvNEqKSlBYWEhioqKuD1u+TRSqbTNc1VVVaGvrw89PT0u0D76WFtbG1paWhCJRNDU1IRQKIRIJIKWlhY0NTWH3VfN1dXVqKurg0QiQWVlJWprayGRSFBbW4uqqirU1NSgoqICFRUVXECV38sft7S0tJmnmppamyBgZGQEMzMzGBoathluampKHduTftfU1ISCggLk5+dzO1VFRUVcKCoqKuLGNTY2tnmuuro69PX1YWBgwAVa+U2+46yjowMtLS0IhULo6OhAJBJBKBRCS0trWFx4VldXh7q6OtTW1qKiooJ7XFdXh4qKCm7nVh5QW9+Xl5ejrq6uzfyUlZW5AxXytkK+c2FmZsYdzLCwsKALLR9B4ZWQQaCkpIRrAB8XsOSPa2trUVNT0+V8dXV1uWCro6PDDRMIBNDU1ISamhqUlZW5D6ZHx8mpqKh0Goa7GlddXd0uEMpVVVW1OYokkUjQ2NgIqVTKvS75NB2Nk3+4SCSSbq0HLS2tLncGHn1saGhIgZQMWmVlZSgtLW0XsB69ycfJw1ln71cA7cKskpISRCIRN05JSQlCoRCqqqpQV1eHhoZGm/YFAEaMGMG1RY+SP+dRTU1N7YKhXG1tLZqbm7m/5W1FY2MjJBIJWlpaUF1dDeDhN2aMMe458p3b2tpablxn5AcM5OH/0Z2Ajv42MjKibup6icIrIUPUyZMnsW7dOshkMmzfvh1eXl7cEUaJRMIdLWgd8BhjqKysBPDfRl/eyHc0Tk7+gdCRrsY9GoK7Gif/4Gr9gaitrQ1lZWWoqalBU1OzzbhHg7m2tjaEQiGEQiF0dXVx7NgxbNmyBdbW1ti/fz88PDx6uIYJGX7q6+tRV1eH6upqVFVVceFOHvDkj+vq6tDc3Iza2to2bYc8AMvbhUeDp7y96UhNTU27b6EAQCAQdLojKW8b5DQ0NKCurs7tVLd+ro6ODkaMGMG1Perq6tDS0uKOMsuPOmtra3M7vPJhZGBReCVkiKmursZbb72FPXv2YMmSJfjhhx9gYGDAd1kKKTs7G2vWrMHly5fxxhtv4MMPP6SLXAghRMFReCVkCDl79izWrl2LxsZG/PDDDwgODua7JIXHGMOePXvwxhtvwMbGBvv374e7uzvfZRFCCOkE9YBMyBAgkUiwefNmzJkzB97e3khPT6fg2k0CgQDr1q1DSkoKDA0N4e3tjXfffZfrx5cQQohioSOvhAxyUVFRWL36/7d353FN3en+wD8JRJawBJRdRJRFWUUQi6AWqFpcKjAtTqutS6vUttNtpqN3bq917nRmpIsz7dx2rG1Hb63TV2s72tpCXYrtAGpBBDFsiqCyh50EEiDJ9/eHv5xLCCAgcAI879crL5JvTs55cki+5zlPvuecrWhqasI777yDxx9/nO+QJixdFfbll1/G3LlzcfjwYYSEhPAdFiGEkF6o8krIBKVUKrF7924sX74cvr6+kEqllLjeo95VWIlEgsWLF2P37t16B6cRQgjhF1VeCZmAzp8/j61bt0ImkyElJQU7duzgO6RJR6vV4qOPPsJLL70Eb29v/O///i+Cg4P5DosQQqY8qrwSMoHoqq3Lli3D3LlzIZVKKXEdI0KhEDt27EBOTg7MzMxw3333ISUlZdDzXBJCCBl7VHklZIK4ePEitmzZgrq6OrzxxhuUtI4jtVqNt99+G6+99hpCQkJw6NAhzJs3j++wCCFkSqLKKyFGTqVSYffu3YiKisLs2bNx9epVSlzHmampKXbt2oXc3Fyo1WosXLiQqrCEEMITqrwSYsSys7OxZcsWVFdX480338T27dvpcoI801Vh9+zZg7CwMBw6dAg+Pj58h0UIIVMGVV4JMUI9PT1ISUlBVFQUZsyYgcuXL2PHjh2UuBoBXRX20qVLUKlUWLBgAVJSUqDVavkOjRBCpgSqvBJiZAoKCrBlyxaUlpZiz549eOWVVyAU0n6mMerp6cH+/fuxZ88eLFq0CIcPH4aXlxffYRFCyKRGW0RCjIRarUZKSgoWLVoES0tL5OfnY9euXZS4GjGRSIRdu3YhJycHHR0dCA4OxjvvvAOqCRBCyNihyishRkAqlWLLli0oKirCa6+9RtXWCainpwd//OMf8frrryMmJgYfffQRZs2axXdYhBAy6dDWkRAe6aqtYWFhmDZtGvLy8qjaOkGJRCLs3bsXWVlZqKysRGBgIA4ePEhVWEIIGWW0hSSEJ4WFhViyZAn27t2L3//+98jIyICvry/fYZF7tHjxYuTl5WHnzp145plnEBcXh6qqKr7DIoSQSYOSV0LGmVarxTvvvIPQ0FAIhUKu2mpiYsJ3aGSUmJubY9++fcjIyMDNmzcREBCAgwcP8h0WIYRMCpS8EjKObty4gfvvvx+vvPIKdu/ejaysLLpS0yQWERGBvLw8PP3009i5cyfWrFmD6upqvsMihJAJjZJXQsYBYwwHDx5EcHAw2trakJ2djb1791K1dQqwsLDAvn378O9//xvXr1+nKiwhhNwjSl4JGWMVFRWIjo7Gc889h+eeew45OTlYsGAB32GRcRYZGYn8/HwkJydj586dWLduHWpra/kOixBCJhxKXgkZI7pqa1BQEJqbm3Hx4kXs27cP06ZN4zs0whNLS0vs27cPP/74I4qLixEcHIwvv/yS77AIIWRCoeSVkDFw8+ZNxMbG4tlnn8Wzzz6LS5cuYeHChXyHRYzE0qVLcfnyZSQkJCApKQlJSUlobGzkOyxCCJkQKHklZBT1rrbKZDJcuHCBqq2kXzY2Nvjggw+QlpaGixcvIiAgAMePH+c7LEIIMXqUvBIySm7duoWVK1fi2WefxTPPPIPc3FyEhYXxHRYxcqtWrcLVq1exfv16JCYmIikpCU1NTXyHRQghRouSV0JGwbFjxxASEoKamhpkZWVh3759MDMz4zssMkHY2trigw8+QGpqKs6fP4+AgAB8/fXXfIdFCCFGiZJXQu5BXV0dHnroIfzyl7/EI488gpycHISHh/MdFpmg4uLiIJVK8dBDDyE+Ph5JSUlobm7mOyxCCDEqAkYX3iZkRI4dO4ann34aEokEhw4dwrJly/gOiUwi3333HXbs2MGNo167di3fIRFCiFGgyishw1RfX4+EhARs2LABDz/8MAoKCihxJaNuzZo1kEqleOCBB7Bu3To88cQTkMvlfIdFCCG8o8orIcNw7Ngx7Ny5EzY2Nvj4448RHR3Nd0hkCjh27BieeeYZiMVifPzxx4iNjeU7JEII4Q1VXgkZAplMhl/84hfYsGEDfvGLX6CgoIASVzJuHnnkERQWFiI0NBQrVqxAcnIyFAoF32ERQggvqPJKyF1Q1YsYE6r+E0KmOqq8EjKAlpYWPPHEE0hKSkJcXByuXr1KiSvhna4KGxwcjNjYWCQnJ6Ojo4PvsAghZNxQ5ZWQftCR3mQioDNeEEKmIqq8EtJLa2srkpOTsXbtWkRGRkIqlVLiSoyWrgrr7++P6OhoJCcno7Ozk++wCCFkTFHllZD/Ly0tDdu3b4dGo8GBAwewfv16vkMiZMiOHTuG5ORkuLi44NChQ3SxDELIpEWVVzLpSaXSQZ9va2tDcnIyVq9ejSVLlkAqlVLiSiacRx55BHl5eXB1dUVkZCR2796Nrq6uQV9zt+8GIYQYI0peyaT27bffIjw8HKWlpf0+f+rUKQQGBuLrr7/Gv/71L3zxxReYPn36OEdJyOjw8PDA6dOn8d577+H9999HaGgoLl261O+0p06dQnh4OCWwhJAJh5JXMmlVVlZi06ZNUKlU2LRpEzQaDfdce3s7kpOTERcXh/vuuw9SqRQJCQk8RkvI6BAIBNixYwcKCgrg6OiIiIgI7N69G93d3dw0ra2t2Lx5M1QqFRITE+lsBYSQCYWSVzIpqdVqJCUlobOzE4wx5OXl4a233gIAZGRkYOHChTh+/Di++OILfPHFF5gxYwbPERMyumbPno0ffvgB7733Ht577z2EhYXh8uXLAIAXXngBTU1NYIyhoqICTz75JM/REkLI0NEBW2RS2rVrF95++229aqtIJMKjjz6KI0eOIDExEe+//z4cHR15jJKQ8XH9+nVs3boVOTk5ePLJJ/H3v//dYJrDhw9j8+bNPERHCCHDQ8krmXTS0tKwZs0a9P1oi0QiODo6IiUlBRs3buQpOkL4odVq8ac//Qn79+9HW1sbtFqt3vPm5ubIzc2Fn58fTxESQsjQ0LABMqlUVVXhscceg0AgMHiup6cHdXV1qKio4CEyQvglFApRWFgIhUJhkLgCd4baJCQk0HliCSFGjyqvZNJQq9VYtmwZLl26hJ6engGnMzExQXZ2NhYuXDiO0RHCr2+++eaup4AzNTXFpk2bcOjQoXGKihBCho8qr2TS2LNnD7KzswdNXIE7R2Nv3rz5rtMRMlk0NjZi27ZtEAoH7/LVajUOHz6MI0eOjFNkhBAyfJS8kknh1KlT2Ldvn94BWv0xNTUFYwxSqRQHDx4cp+gI4dfevXvR1NQEoVAIExOTQacVCARITk5GSUnJOEVHCCHDQ8MGyIRXX18Pf39/tLS0GIzlEwgEMDExgVqthkQiQWxsLFauXIkVK1bA09OTp4gJGX/l5eU4e/Yszpw5g9OnT6O9vR3Tpk2DWq02+N6IRCLMmTMHly9fhqWlJU8RE0JI/yh5nQLkcjnUajXUajXkcrleGwAwxtDa2jrg6+/2PHDnSGULC4shP29tbQ1TU1OYmprC2tpar204NBoNli9fjgsXLkCr1UIgEMDU1BQ9PT2wtLTE/fffj1WrViE2Nhb+/v7Dmjchk5VGo0Fubi5++OEHnD59GhcuXEBXVxfMzMy4S8oKBAJs3boVH3/88YiXo1QqoVKp9PqelpYW7vnOzs4BL2Hb3d096MUTButzevcrAGBrawuhUAhLS0uYmZlBJBLByspqJG+JEGIEKHk1AlqtFi0tLWhtbUVraytaWlqgUCigVCohl8shl8uhVCqhUCjQ3t4OpVKJjo4OtLW1QalUorOzkzv1TX+J6kTTX0JraWkJCwsL2NraQiwWw8LCAjY2Nrhy5Qp+/vlnAHcOxJo7dy5CQ0OxePFihISEYPr06ZBIJLCzs6MKEiEDUKlUOHv2LE6dOoUffvgBpaWlXDV227Zt8PHxQXt7Ozo6Ori+Ry6Xc49bW1uh1WrR1tYG4M4V7O42hMdY2NnZAfi/vsba2hpisRhisRgSicTgsZWVFffYzs4ONjY2sLe3526EkLFHyeso0mg0aGxsRENDAxobG1FXV4eGhgYuMe37V3e/vb293/npqgPW1tawsLAwuG9jYwNzc3PuvomJCVdZEAqFsLW1BYBB23SsrKwgEokGfG93e753JXcoz+uS7a6uLu7UPIO1KRQKqFQqtLe3c4n97du3ce3aNVhYWHBDA1Qq1YBJ+7Rp07hEViKR6N23s7ODnZ0dZsyYAQcHB8yYMQNOTk5wdHSEWCwe8H0RYow6OjpQV1fH9UE1NTVoampCc3PzgLf+vr8mJiYQCARwcXGBvb39gEmcRCKBQCDg/ur6CzMzM1haWur1PboqKIBBK6C6+Q1ksD5HV/HV0VV7FQoFenp6uD5Go9Fw/a+ur2lra+OS8vb2doMkXaFQcI/7i7l3Itv3Nn36dDg5OcHFxQUODg5wdXWFjY3NgO+RENI/Sl7vgjGG+vp6VFdXo7q6GlVVVZDJZGhoaEB9fT0aGhq4ZLWxsVHvxPhCoRAODg6wt7cfNGnq77mR/IQ+1ajV6gHXkVwuh0KhMNhRGGwnorm5GY2NjQYbJQsLCzg4OMDJyYlLbB0cHODs7AxnZ2e4u7vDxcUF7u7ugw6dIOReKZVK3Lp1C7dv30ZlZSWqq6shk8lQU1MDmUyG+vp61NbWGnyGZ8yYgRkzZgyaWPW96XaIgcG/a1OZrvjQ3Nx8150DXf/S0NCgN8bY3NycS2gdHR25fsXZ2RmzZs2Ch4cHZs2aRUkuIb1M6eSVMYaamhpUVFSgqqoKNTU1qKysRE1NDaqrq1FZWYna2lq9Uyrp9pwdHBzg6OgIR0dHg0qdbkPh4ODQ78nyiXHr7OxEY2Ojwc6Jroql2wDV1taivr4e3d3d3Gvt7e3h6uoKd3d3uLq6YubMmXBzc4Orqys8PDwwZ84cGr5ABtTc3IyysjIuQb19+zZu3bqFyspKVFZWoqGhgZtWLBbD3d1dL+FxdHSEq6srt3Olq/BNmzaNx3dFetNoNFwBpLq6Gg0NDairq0NtbS1XJZfJZKiurtY71sDW1lYvmXV3d+cee3l5wcnJicd3Rcj4mvTJq0qlQk1NDcrLyw1uJSUlehUKOzs7zJkzBy4uLnB1deX+6trc3d1p75cYaGlpQU1NDWpra7m/5eXlBm06us9Zf7dZs2ZRhWuSa2lp6bc/0t10en9OevdFuscuLi60czzJ9d5+9e5bdI9v3rzJDbEyMzODm5sb/Pz84O/vr9eveHp60meFTCqTInlVq9UoLy9HUVERSkpKUFxcjOLiYpSVlXFjnYRCIdzc3ODp6QlPT0/uC6277+zsfNcTeBMyUh0dHbh58ybKy8tRUVGBiooKvfsKhQLAnYPVZs2aBV9fX/j5+WHevHmYP38+5s+fTweDTDCtra24evUqpFIpCgoKIJVKUVxcjKamJgB3xnt6enrCy8sLPj4+8PLygre3N7y8vODu7j7oGHNCgDsH+9bU1OD69esoKysz+Ksb92tjYwMfHx8EBQUhICAAgYGBCAwMpGotmbAmVPKqVqtRUlKCgoICvUS1rKwM3d3dEAgE8PDw4Db83t7eXJLq4eGhd4ASIcZEJpNxCa3uV4Hi4mKUlpZyia2DgwP8/f3h6+uL+fPnw8/PDyEhIZgxYwbP0U9tWq0WJSUluHz5Mq5evcolrJWVlQDu/NyrSxh0/ZK3tzc8PDyoyk7GDGMMlZWVXDJbXFzM7Ujphp84ODhwiWxAQABCQkIQFBREO07E6Blt8trT04Nr164hNzeXu+Xl5aGzsxMikQju7u56P4/4+flhwYIFdO4+Mum0tLSgsLAQRUVF3N/ePzG7uLggNDQU/v7+8PPzQ2hoKPz8/OhnwjFSU1Oj1y+dP38ezc3NEIlE8Pb25v4Pur/0vyDGpm+fkpubiytXrkChUHCf46ioKERGRlJ/QoySUSSvWq0WUqkUGRkZuHjxIvLy8lBSUgKNRgMbGxssWLAAISEhCAkJwYIFC+Dn50d7hmTKk8lkyMvL07uVlZWBMQZ7e3ssXLgQYWFhiIyMRGRkJHc+SzJ0Wq0WV65cQXp6OjIzM5GdnY2amhoIhULMnz8fixYtQnh4OMLDw6liRSY03S8I2dnZ3K2goAA9PT2wt7dHeHg4IiIiEBMTg8WLF9NnnfCKl+RVqVQiJycHmZmZyMrKQlZWFtra2mBjY4OIiAgsXLiQS1bnzp1Le3yEDJFcLkd+fj6XzGZnZ6O4uBgCgQB+fn5cNWXp0qXw8PDgO1yjVFRUhHPnziE9PR0//vgjmpub4eDggKVLl2Lx4sUIDw9HaGio3hWcCJmMVCoV8vPzkZ2djZycHPz000+orKyEWCzG0qVLER0djZiYGISEhHCnVSNkPIxL8qrVapGbm4u0tDScOnUKly5dQnd3N9zc3LB06VJuYxoQEEBfAEJGWVNTE7KysridRd33b+bMmYiOjkZcXBxWrlyJ6dOn8x0qLzo7O3H69GmcOHECp06dQl1dHWxtbbFs2TLExMQgJiYGgYGBtBNNCICysjKkp6fj3LlzOHfuHOrr6yGRSBATE4P4+HisXbuWfuUhY27Mktfm5macPn0aaWlp+P777yGTyTBz5kzExcVh2bJliIqKwuzZs8di0YSQQfT+5ePs2bPIzMyEVqtFeHg41qxZg7i4OISEhEzqZK25uRnffvstl7CqVCpERERg7dq1iImJQWhoKO1IE3IXjDEUFRUhPT0dqampSE9PB2MMy5cvR3x8POLj4+Hm5sZ3mGQSGtXktbm5GZ9//jk+++wznD9/HgKBAFFRUXjwwQcRFxeHoKCg0VoUIWSUtLe348yZM9yOZnV1NZydnZGQkIBNmzYhIiJiUiSy3d3d+Prrr/Hxxx/jhx9+gFAoRExMDBISErB+/Xo6bRAh96itrQ2pqak4ceIE0tLSoFAosHjxYmzduhWPPvooDbUho+aek9euri6kpqbik08+QWpqKkQiERISEhAfH48HHniAu541IcT4McZw5coVpKam4rPPPoNUKoWXlxc2btyITZs2wcvLi+8Qh+3GjRv48MMPcfjwYTQ2NiIuLg6PPfYYVq9eTf0TIWNEpVLh7Nmz+Pzzz/Hll19CJBLh0UcfxY4dOxAaGsp3eGSCG3Hyeu3aNfztb3/DP//5T7S2tiImJgaPP/44EhMT6XRVhEwS+fn5OHLkCD777DPU1dUhIiICO3fuRFJSktFfcvT06dN488038cMPP8DNzQ1PPvkknnzySbi7u/MdGiFTSnNzM44cOYKDBw+iqKgIoaGhePnll7FhwwYankNGhg3TxYsX2bp165hQKGRz585lKSkprKqqarizGXOfffYZA8AAMDMzM77DmRTefPNNbp26ubnxHY5Rm2zrSq1Ws7S0NLZhwwYmEomYq6srS0lJYQqFgu/QDJw5c4aFh4czAGzlypXsm2++YWq1mu+wGGPUL42FyfZdm+wyMjLYo48+ykxMTJi3tzc7evQo02q1fIdFJpghJ6+FhYVs3bp1DABbsmQJO378ONNoNGMZ26iIjY012EjI5XLm5eXF1qxZw1NUE1twcDBtJIZoMq6r27dvs9/+9rfM2tqaOTk5sXfffZf19PTwHRYrLy/n+qi1a9ey7OxsvkMaEPVLo28yftcms+vXr7OtW7cyExMTtnjxYpaTk8N3SGQCEd6tMqtSqfC73/0OCxYsQFVVFVJTU5GVlYX4+HgIhXd9uVFijEGr1UKr1Y54HlZWVoiKihrFqAiZGNzd3ZGSkoIbN25g06ZNeOWVVxAWFoaff/6Zt5gOHDiAoKAgVFRU4OzZszh58iQWLVrEWzwjQf0SmUq8vLzwj3/8A7m5ubCwsEBERAReffVV9PT08B0amQAGzT7Ly8sRGRmJ999/H/v370dOTg7i4uLGK7YxY21tjRs3biA1NZXvUAiZsBwcHPDWW2+hoKCAO4n/22+/DTaO1z3p7u7Gtm3b8Nxzz+H5559Hbm4uYmNjx235o4n6JTIVBQcHIz09He+++y7++te/Ii4uDi0tLXyHRYzcgMlrfn4+7rvvPmi1Wly6dAnPPfccDawmhBjw8fHhDo76j//4DyQnJ99T9XCoNBoNNm7ciGPHjuFf//oX/vjHPxr9QWSEEEMCgQA7d+7E+fPnUVZWhuXLl1MCSwbVb/JaWVmJFStWICgoCJmZmRPi9DglJSWIj4+Hra0td+m6zMxMg+lOnDgBgUDA3VQqFfdcV1cX9uzZg3nz5sHS0hL29vZYt24dvvnmG2g0GgDAW2+9BYFAgI6ODmRlZXHzMTU15eajVqvx+eefY8WKFXB2doaFhQUCAwPxzjvv6G3U+8Zy8+ZNbNiwARKJBNOnT8fatWtx48YNg/fQ1NSEl19+GXPnzoWZmRlmzpyJBx54AIcPH4ZSqdSbtqGhAc8//zxmz56NadOmwcHBAYmJicjPzx+Vdb5mzRrY2trC0tIS0dHRyMrKAgC0trbqvTeBQIDXX3+dWz+92x9++OEhL3O46+z111/npu39c+r333/Ptc+YMWPA+d+6dQsbNmyAtbU1pk+fjscffxwtLS24efMm1q1bB2tra7i4uGD79u2Qy+UjWlc6Q/3cGCOBQIAXXngBX375JT755BP87ne/G/Nl/vrXv0ZaWhpOnz6Nhx56aMyXNxLUL02Nfmk462C4fZLufysQCDBz5kzk5OQgNjYW1tbW4/7+xlpQUBB++ukntLS0YMOGDeP6Kw6ZYPobCBsbG8v8/f1ZR0fHeI6/HbHr168ziUTC3Nzc2OnTp5lcLmcFBQVs5cqVbPbs2f0e1bt+/XoGgCmVSq7tqaeeYra2tuz06dOss7OT1dXVsd/85jcMADt37pze68ViMYuMjOw3npMnTzIA7E9/+hNrbm5mDQ0N7N1332VCoZD95je/GTCW9evXs/PnzzOFQsHOnDnDLCws2KJFi/Smra2tZZ6enszZ2ZmdPHmStbe3s7q6OvaHP/yBAWB/+ctfuGlramqYh4cHc3JyYt999x2Ty+VMKpWy5cuXM3Nzc3b+/PnhrGZOcHAws7W1ZdHR0SwzM5PJ5XKWk5PDgoKC2LRp09iPP/7ITbtq1SomFApZWVmZwXwiIiLY0aNHRxTDcNYZYwP/v0JDQ9n06dMHnH9iYiK7dOkSUygU7JNPPmEAWFxcHFu/fj3Ly8tjcrmcHThwgAFgL730ksF8hrOuhvu5MVaHDx9mQqGQ/fTTT2O2jIsXLzKhUMg+/fTTMVvGvaJ+aWr1S8NZB4wNv08KDg5mYrGYRUREcP+P8e53x0t2djYzNTVlhw4d4jsUYqQMktfs7GwGgGVkZPARz4g88sgjDAD78ssv9dqrq6uZmZnZkDcSnp6ebMmSJQbT+vj4DHsjcf/99xu0b9q0iYlEItbW1tZvLCdPntRrf/jhhxkA1tDQwLVt2bKFAWCff/65wfwffPBBvQ5y8+bNDIBBR1VbW8vMzMxYaGhov/HfTXBwMAPALly4oNdeUFDAALDg4GCu7dSpUwwAe+aZZ/SmzczMZG5ubqy7u3tEMQxnnTE28uT1u+++02v39/dnAAwSM09PT+a4yk3eAAAU/0lEQVTr62swn+Gsq+F+boxZbGwsW7169ZjN/7HHHmOLFy8es/mPBuqX7pgq/dJw1gFjI0teAbC8vDy99vHsd8fTtm3b9N4TIb0ZJK9//vOf2ezZs/mIZcSsra0ZACaXyw2eCwwMHPJGYufOnQwA2759O7tw4cKg54YcbCMxEN35CPtWFnSx1NXV6bW/9NJLDAC7cuUK12Zra8sAsPb29rsuz9bWlgmFwn6TnoULFzIArLKycljvgbE7nai5uXm/5+ZzdXVlAFhNTQ3XFhgYyCwtLVljYyPXtn79erZv375hL7v364e6zhgbefJaX1+v175ixQoGwOBXiaioKGZtbW0wn+Guq/4M9LkxZocPH2bm5uZjdjo9d3d39uabb47JvEcL9Uv9m6z90nDWAWMjr7z2Z7z63fGUmprKALDW1la+QyFGyGDMa2Nj44S6xndXVxfkcjnMzc37vbKXo6PjkOf13nvv4ZNPPkF5eTliY2NhY2ODBx98EMePHx9WTG1tbdizZw8CAwNhZ2fHjTF65ZVXAACdnZ39vq7vpSp1B5/oxqN1dXWhra0N5ubmd71GtG5arVYLW1tbg3FQly9fBgBcv359WO9NZ/r06f1e7163vmUyGdf24osvorOzE++//z6AO1dnS09Px44dO0a07N7uts7ulY2Njd5joVAIExMTWFpa6rWbmJgMuMyhrquRfm6MkbOzM1QqFRQKxZjMv7m5WW9coLGhfql/k7VfGs46uBcSiaTf9vHud8eDg4MDgDvfdUL6Mkhe586di9LSUr0DBoyZmZkZrK2tB9xQDueDLxAI8Pjjj+Ps2bNobW3FiRMnwBhDYmIi9u/fbzDtQNatW4c//OEP2L59O65duwatVgvGGP7yl78AwIgHoZuZmcHW1hYqlWrQg4N000okEpiamqKnpwfsTpXd4BYdHT2iWNra2vpt13WevTfOGzduhJOTE/7nf/4HXV1dePvtt7F582bY2dmNaNkjIRQK0d3dbdDe2to65sse6roaq88NH/Lz8+Ho6GiQ/I+W2bNno6ioaEzmPRqoXxp42snYLw1nHeiMpE9qamrq9/9krP3uvSgsLIRIJIKbmxvfoRAjZJC8JiYmQqlU4qOPPuIjnhHRnXv2+++/12tvbGxEaWnpkOcjkUhQUlICABCJRFixYgV35O13332nN62lpaVex+Pr64uDBw9Co9EgKysLzs7OeP755+Hg4MBtUPoecTsSCQkJANDvuSBDQkLw0ksvcY8TExOhVqsNjmoHgJSUFMyaNQtqtXpEcSgUCly5ckWv7erVq6ipqUFwcDBcXFy4djMzMzzzzDOQyWR4++23cfToUbzwwgsjWu5Iubi4oLq6Wq+trq4Ot2/fHvNlD2VdjfXnZjwpFAr8/e9/x2OPPTZmy0hMTMSRI0eGnCjwgfqlO6ZKvzScdQCMrE9SqVTIycnRazPmfnektFotDhw4gHXr1tHp70j/+htL8OqrrzJLS0uWm5s7hiMWRk9ZWRmzt7fXO6q3sLCQrVq1ijk6Og55bJmtrS1bvnw5u3LlClOpVKy+vp7t3buXAWCvv/663usffPBBZmtry27fvs3Onz/PTE1NWVFREWOMsZiYGAaAvfHGG6yhoYF1dnay9PR0NmvWLAaAnTlz5q6xMMbYrl27DAbo645odXFxYd9++y1rb29nlZWVbOfOnczJyYndunWLm7a+vp7NnTuXzZkzh6WmprLW1lbW1NTEDhw4wCwtLfs9sGAodGOvoqKi2MWLFwc96lWnoaGBWVhYMIFAwNavXz+i5fY2nHXGGGPPPfccA8D+9re/MblczsrKylhSUhJzc3MbdMxr3/mvWrWKmZiYGEy/fPnyfsejDWddDfdzY4w0Gg177LHHmKOj413H8t4LmUzGZsyYwbZt2zZmy7hX1C9NrX5pOOuAseH3SbqzKcTGxt71bANj8f7G01tvvcVEIpFBP06ITr/Ja09PD1u5ciWzt7c3OHLTWJWWlrL4+HhmY2PDncrl22+/ZbGxsQwAA8CefPJJdvz4ce6x7rZx40bGGGP5+fksOTmZzZ8/n1laWjJ7e3t23333sQ8//NDgIICSkhK2dOlSJhaLmbu7O3vvvfe45xoaGlhycjJzd3dnIpGIOTk5sS1btrDdu3dzywwNDWUXLlwwiOU///M/GWPMoL339c4bGxvZiy++yDw9PZlIJGIuLi7sl7/8Jbt27ZrBemlqamIvv/wymzNnDhOJRMzBwYGtXLlyRImQ7sAOAMzNzY1lZ2ez6OhoZmVlxSwsLNjy5ctZZmbmgK/fvn17v0fqD8dI11lrayt76qmnmIuLC7OwsGBRUVEsJyeHhYaGctPv2rVrwPnn5OQYtP/5z39mGRkZBu2vvfbaiNbVUD83xqqrq4tt3ryZmZubj0ui/fXXXzMTExPu/2+MqF+aGv2SznDWwVD7JJ3g4GDm5ubGioqK2KpVq5i1tfW4v7/xcOTIESYUCtkbb7zBdyjEiPWbvDLGmFKpZGvXrmXTpk1j77zzTr9HcBIyHP/4xz+MOvkiI1deXs4WL17MrKys2Pfffz9uy/3444+ZiYkJ27x5s0GFkJChmCj9ki55Ha6J8v40Gg37/e9/zwQCAfvtb3/LdzjEyA14eVhzc3N8/fXX+K//+i/8+te/xtKlS1FQUDDQ5ITc1YEDB/Dyyy/zHQYZRd3d3di3bx8CAgKgVCpx6dIlrFq1atyWv23bNpw8eRInTpzAwoULkZ2dPW7LJpPDZO+XJsL7Ky8vR3R0NF5//XW8//77SElJ4TskYuQGTF6BO0dDvvrqq7h06RK0Wi1CQkKQlJQ04tOYkKnlo48+QkJCAhQKBQ4cOICWlhYkJSXxHRYZBVqtFseOHYOfnx/++7//G6+88gqys7Ph6+s77rHExcWhuLgYc+fORUREBJ544gnU1taOexxkYpjs/dJEen8dHR3Yu3cvAgIC0NzcjAsXLuDpp5/mOywyEQy1RKvRaNg///lP5uvry0xNTVlSUhK7ePHiWFaFyThBn3Fs/d1ee+21Yc/3ww8/ZACYqakpCwoKGvQAwLGKgYyu9vZ2tn//fjZ79mwmEonY9u3b2e3bt/kOi/PNN98wT09PJhaL2fPPP8+qqqr4DomMEPVLd/Qe06u7DTbOezjvjy9yuZz99a9/Zc7OzszOzo7t27ePqVQqvsMiE4iAseGd3E+tVuPYsWPYv38/Ll26hIULF+Lxxx/Ho48+OqEubkAIGRqtVosff/wRR44cwVdffQXGGLZu3YoXX3wRc+bM4Ts8A0qlEh988AHefPNNNDc34+GHH8b27duxbNkyvkMjZEorKCjAhx9+iE8//RRarRa/+tWv8NJLL2H69Ol8h0YmmGEnr71lZmbi0KFD+Oqrr9DR0YGVK1di48aNiI+PN7gCESFkYpFKpfj0009x9OhRVFVVISwsDJs2bcITTzwxIU50rlKpcPToURw8eBDZ2dmYN28etm/fjieeeMKor85FyGTS0dGBzz//HB9++CEuXrwIb29vPPXUU9i+ffuE6EeIcbqn5FVHqVTim2++waeffopTp07B3NwcK1euRFxcHOLi4uDq6joasRJCxpDuxPFpaWn47rvvIJVKMXv2bGzcuBGbNm3CvHnz+A5xxPLz83Hw4EEcPXoUXV1dWLVqFeLj4/HQQw9R1YeQUdbR0YG0tDScOHECJ0+eRFdXFxISErBjxw7cf//9g14JjpChGJXktbeGhgZ8+eWX+Pbbb3Hu3DmoVCosWLCAS2QjIiJgYmIymoskhIxQXV0d0tLSkJaWhjNnzqC1tRU+Pj5YvXo1EhMTERUVNak2NB0dHTh27Bi++uornD17Fj09PVi2bBkSEhIQHx8Pd3d3vkMkZEJqamrCyZMncfz4cZw5cwbd3d2IjIxEYmIiNm7cSL92kFE16slrb0qlEj/++CNSU1ORlpaGGzduQCKRICoqCpGRkYiKikJYWBjMzc3HKgRCSC+3b99GRkYGzp8/j4yMDEilUpibm2P58uVYvXo1Vq9ejblz5/Id5riQy+VIS0vD8ePHkZqaCrlcjqCgIMTExCA6OhrLly+HjY0N32ESYpRUKhXOnz+Pc+fOIT09HT///DNEIhFiY2ORkJCAhx56CA4ODnyHSSapMU1e+7p27RpOnTqFzMxMZGZmoqamBmZmZggLC+MS2iVLltDPeISMAo1GA6lUiszMTGRlZSEjIwNVVVUQiUQICwvDkiVLEBMTg/vvv3/Kj1Hv6urCuXPncOrUKaSnp+Pq1asQCoUICwtDdHQ0YmJiEBkZOeXXE5m6enp6kJ2djfT0dJw7dw4XLlyASqWCl5cXoqOjsWLFCjz44IOwtrbmO1QyBYxr8tpXTU0NsrKyuI1rXl4etFotXFxcEBoayt38/f2N8qhmQoyFWq1GaWkpcnNzuVt+fj46OjpgZWWF++67j/u1IzIyEhYWFnyHbNQaGxtx4cIFZGVl4ezZs7h8+TKEQiF8fX31+qbw8HBMmzaN73AJGXU1NTXIzc3lttGXL1+GUqmEs7Mzli5digceeAArV67E7Nmz+Q6VTEG8Jq99NTU14eeff8bly5eRl5eHvLw8VFRUAACcnJwQEhKChQsXYsGCBZg3bx58fHxgZmbGc9SEjK+6ujoUFxejsLCQ+64UFhaip6cHYrEYwcHBCAkJQUhICBYtWoSAgAAIhYNej4TcRU1NDTIyMpCdnY3s7GxcvnwZnZ2dsLKyQmhoKBYtWoRFixYhMDAQ3t7eMDU15TtkQoaEMYaKigpIpVLk5uZyn/Hm5maIRCIEBwcjPDwc4eHhWLJkCby9vfkOmRDjSl7709rayiWyug11aWkpNBoNTExM4Onpifnz52PevHmYN28e/Pz8MG/ePEgkEr5DJ2TENBoNKioqUFxcjOLiYpSWlqKoqAglJSVobW0FANjb23NJqu7m4+NDB0SOA7VajcLCQvz888/cxr6oqAgajQZmZmbw8/ODv78/AgMDERgYiICAADoYjPBOJpPh6tWrkEqlkEqluHr1KgoLC6FQKAAAXl5eXKIaHh6OkJAQOiaFGCWjT177093djdLSUpSUlKCkpATFxcUoKSlBaWkpOjs7AQDOzs7w8fGBp6cnPD09MWfOHO4vnbqLGIPOzk5UVFSgvLxc7++NGzdw/fp1dHd3AwDc3d31ds58fX0xf/58ODs78/wOSG8qlQpFRUVcQlBQUACpVIrq6moAgEQiwfz58+Hj4wNvb294eXlxf+nAMDJaVCoVrl+/jrKyMly/fp27X1RUBJlMBgCYPn06goKCEBAQgICAAAQGBsLf358+h2TCmJDJ60AYY7h58yZXpbpx4waXENy8eRNdXV0AAHNzc4OkdubMmXBzc4ObmxtcXV1pHBu5Z01NTaipqUFlZSVqa2tx8+ZNvSS1rq6Om9bR0VFvB0uXoPr6+tIBEBNcS0sLV+0qKipCWVkZysrKcOvWLajVagB3hkV5e3tzNw8PD8yaNQuzZs2Cq6srDUMgHMYYamtrcfv2bVRWVuLWrVt6yWpVVRUYYxAIBJg5cya3g+Tr68v9CuDi4sL32yDknkyq5HUwjDFUV1ejoqKi32pXXV0dNBoNN72TkxNcXFy4pNbV1RXu7u5wcXGBq6srZsyYAQcHB4hEIh7fFeFDe3s76urq0NDQgJqaGr0EVfe3qqoKKpWKe421tTU8PDz0dph63xeLxTy+I8KHnp4eVFRUcNUxXQJSVlaGyspK9PT0AABMTEzg4uLCJbTu7u5wd3eHh4cH3Nzc4OzsTH3RJKHVaiGTySCTyVBVVYXKykpUVlbi9u3bXLJaVVXF/Sqj+2zoEtTe1Xxvb2/6yZ9MWlMmeb0bjUaD+vp6vSSkpqYG1dXVqKqq4hIU3bAEHXt7ezg6OnLJrG5Dors5OzvDzs4OEokEEomEfpYxMj09PWhtbUVLSwtaWlrQ0NCAxsZGyGQy1NfXc491yWpDQwNXwQcAoVAIJycnvR0cV1dXg50eKysrHt8lmWi0Wi3q6upw8+ZNLoGprKzUe9zY2Kj3GkdHRzg6OsLZ2RnOzs5wdHSEm5sb1+bg4AB7e3vY29vTztI4UqlUaG5uRnNzM/drjEwmQ11dHWprayGTybg2mUymV0SxtbXldlT67rjoqvK000KmIkpeh6mtrQ21tbVobGxEQ0MDl9T0l/A0NDRAq9Xqvd7ExIRLZCUSCezs7PSSW12bWCyGhYUFJBIJLCwsYGFhATs7O1hYWMDc3HzKXxNapVJBqVSipaUFSqUSKpWKu69UKtHa2gqFQoHW1lYuOdXd7/24o6PDYN5isRgODg5wcnLidkJ0iYHuse45Jycn2ngQXiiVSlRWVnL9Tu9EqL6+Xi8p0lXqdMzMzGBvbw87Ozsuoe17s7a2hlgshrW1NWxtbSEWiyEWi2FjYwMbG5spcWAgY4zrSzo6OtDR0YGWlhbuvlwuR3NzM1paWrgEte9NqVTqzdPU1JTrO1xdXQ12OHRtbm5uVOwgZACUvI4hrVaLxsZGLlHqm0D1rvj1bevs7DSo8valS2olEgksLS1hZmYGU1NTboyklZUVRCLRXdt0xGLxgGN9TUxMBuxIe3p6uKNV+9Pe3q5XTeg9vVwuh1qtvmtba2urXmI62MdWIBBAIpHAyspKb4eg7w5Cf48dHBzoRPRk0mlqakJjY+OAiVZ/bQqFQm/oS1/m5uYQi8WwtbWFtbU1TE1NuX5o2rRpEIvF3HcRADeNbgdcRzdtf/pOqzNYn6PbsdXp7u5GR0cHl4gC/9fH6HZ81Wo15HI5tFot2traIJfL0dHRMWgfLBKJYG1tPeAOwEDtjo6Ok+qSy4TwgZJXI9c7aetbWezs7IRSqURbWxs6OjrQ3d3NddTAnSqxVqvVa9Mlkr3bdFpaWgaMo+8Goa/BKsF9N0C9E2Fdwtxfm1AohK2tLQDAxsYGFhYW3MbSwsIClpaWA1amCSH3TpfU6fqYjo4OtLe39/tYq9VySaGuv9BoNGhvbwfwf/2Rrq/S6fu4t747vr0N1Of03dHuvaMukUggEAi4PkaXOPfua3S/fInFYlhZWRk81u0Y00G9hPCHkldCCCGEEDJh0GV3CCGEEELIhEHJKyGEEEIImTAoeSWEEEIIIROGKYBjfAdBCCGEEELIUPw/9Qs6LqyzBqEAAAAASUVORK5CYII=\n", "text/plain": [ "" ] @@ -618,8 +621,8 @@ "task_list = [input_node, distributed_node, cudf_distance_node,\n", " numba_distance_node, cupy_distance_node]\n", "out_list = ['distance_by_numba', 'distance_by_cupy', 'distance_by_cudf']\n", - "task_graph = viz_graph(task_list)\n", - "draw(task_graph, show='ipynb')" + "task_graph = TaskGraph(task_list)\n", + "draw(task_graph.viz_graph(), show='ipynb')" ] }, { @@ -628,7 +631,7 @@ "metadata": {}, "outputs": [], "source": [ - "df_w_numba, df_w_cupy, df_w_cudf = run(task_list, out_list)\n", + "df_w_numba, df_w_cupy, df_w_cudf = task_graph.run(out_list)\n", "df_w_numba = df_w_numba.compute()\n", "df_w_cupy = df_w_cupy.compute()" ] @@ -889,7 +892,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "" ] @@ -945,8 +948,8 @@ "task_list = [input_node, distributed_node, cudf_distance_node,\n", " numba_distance_node, cupy_distance_node]\n", "out_list = ['distance_by_numba', 'distance_by_cupy', 'distance_by_cudf']\n", - "task_graph = viz_graph(task_list)\n", - "draw(task_graph, show='ipynb')" + "task_graph = TaskGraph(task_list)\n", + "draw(task_graph.viz_graph(), show='ipynb')" ] }, { @@ -964,7 +967,7 @@ } ], "source": [ - "df_w_numba, df_w_cupy, df_w_cudf = run(task_list, out_list)\n", + "df_w_numba, df_w_cupy, df_w_cudf = task_graph.run(out_list)\n", "df_w_numba = df_w_numba.compute()\n", "df_w_cupy = df_w_cupy.compute()\n", "\n", @@ -1010,13 +1013,20 @@ "client.close()\n", "cluster.close()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "py36-rapids", + "display_name": "Python 3", "language": "python", - "name": "py36-rapids" + "name": "python3" }, "language_info": { "codemirror_mode": { diff --git a/notebook/06_xgboost_trade.ipynb b/notebook/06_xgboost_trade.ipynb new file mode 100644 index 00000000..3f7df60c --- /dev/null +++ b/notebook/06_xgboost_trade.ipynb @@ -0,0 +1,683 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Trade with XGBoost algorithm\n", + "### Background\n", + "In the [portfolio trade example](https://github.com/rapidsai/gQuant/blob/master/notebook/04_portfolio_trade.ipynb), we use gQuant to backtest a simple mean reversion trading strategy on 5000 stocks.\n", + "It shows decent performance by tweaking the moving average window size. Searching for alpha signal is the ultimate goal for the trading companies. A lot of different methods are used to do so. Machine learning approach\n", + "is one of those. It has the benefits of extracting important information in the data automatically given enough computation. There are a few popular machine learning algrithoms, including SVM, Random forest tree etc. Amoung those, XGBoost is known to be a very powerful machine \n", + "learning method that is winning a lot of [ML competitions](https://medium.com/syncedreview/tree-boosting-with-xgboost-why-does-xgboost-win-every-machine-learning-competition-ca8034c0b283). Luckily, the [RAPIDS library](https://github.com/rapidsai) accelerates the XGBoost ML algorithm in the GPU so that we can easily take advantage of it in the gQuant. \n", + "\n", + "In this notebook, we are going to demo how to use gQuant to backtest a XGBoost based trading stragty.\n", + "\n", + "\n", + "### Environment Preparation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append('..')\n", + "\n", + "import warnings\n", + "from gquant.dataframe_flow import TaskGraph\n", + "import nxpd\n", + "import ipywidgets as widgets\n", + "from nxpd import draw\n", + "import os\n", + "\n", + "warnings.simplefilter(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define some constants for the data filters. If using GPU of 32G memory, you can safely set the min_volume to 5.0" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "min_volume = 400.0\n", + "min_rate = -10.0\n", + "max_rate = 10.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note, this notebook requires `cudf` of version >=0.8.0. It can be checked by following command" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8.0+0.g8fa7bd3.dirty\n" + ] + } + ], + "source": [ + "import cudf\n", + "print(cudf.__version__)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The toy example\n", + "To mimic the end-to-end quantitative analyst task, we are going to backtest a XGBoost trading strategy. The workflow includes following steps:\n", + "\n", + "1. Load the 5000 end-of-day stocks CSV data into the dataframe\n", + "\n", + "2. Add rate of return feature to the dataframe.\n", + "\n", + "3. Clean up the data by removing low volume stocks and extreme rate of returns stocks.\n", + "\n", + "4. Compute the features based on different technical indicators \n", + "\n", + "5. Split the data in training and testing and build a XGBoost model based on the training data. From the XGBoost model, compute the trading signals for all the data points.\n", + "\n", + "5. Run backtesting and compute the returns from this strategy for each of the days and stock symbols \n", + "\n", + "6. Run a simple portfolio optimization by averaging the stocks together for each of the trading days.\n", + "\n", + "7. Compute the sharpe ratio and cumulative return results for both training and testing datasets\n", + "\n", + "The whole workflow can be organized into a computation graph, which are fully described in a yaml file. Here is snippet of the yaml file:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "- id: node_csvdata\n", + " type: CsvStockLoader\n", + " conf:\n", + " path: ./data/stock_price_hist.csv.gz\n", + " inputs: []\n", + "- id: node_sort\n", + " type: SortNode\n", + " conf:\n", + " keys:\n", + " - asset\n", + " - datetime\n", + " inputs:\n", + " - node_csvdata\n", + "- id: node_addReturn\n", + " type: ReturnFeatureNode\n", + " conf: {}\n", + " inputs:\n", + " - node_sort\n", + "- id: node_addIndicator\n", + " type: AssetIndicatorNode\n", + " conf: {}\n", + " inputs:\n", + " - node_addReturn\n", + "- id: node_volumeMean\n", + " type: AverageNode\n", + " conf:\n", + " column: volume\n", + " inputs: \n", + " - node_addIndicator\n" + ] + } + ], + "source": [ + "!head -n 29 ../task_example/xgboost_trade.yaml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each nodes has a unique id, a node type, configuration parameters and input nodes ids. gQuant takes this yaml file, wires it into a graph to visualize it. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "task_graph = TaskGraph.load_taskgraph('../task_example/xgboost_trade.yaml')\n", + "draw(task_graph.viz_graph(), show='ipynb')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The features used for XGBoost algorithm are prepared in the `node_technical_indicator` node, where `cuIndicator` module is used to compute the technical indicators in the GPU for all the stock symbols. `node_xgboost_strategy` is the node that is used to compute the trading signals from the stock technical indicators. Each of the gQuant node is implemented by overwriting \"columns_setup\" and \"process\" methods of the Node base class. Please refer to [customize nodes notebook](https://github.com/rapidsai/gQuant/blob/master/notebook/05_customize_nodes.ipynb) for details. Following is the source code for \"XGBoostStrategyNode\":" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "class XGBoostStrategyNode(Node):\n", + " \"\"\"\n", + " This is the Node used to compute trading signal from XGBoost Strategy.\n", + " It requires the following conf fields:\n", + " \"train_date\": a date string of \"Y-m-d\" format. All the data points\n", + " before this date is considered as training, otherwise as testing. If\n", + " not provided, all the data points are considered as training.\n", + " \"xgboost_parameters\": a dictionary of any legal parameters for XGBoost\n", + " models. It overwrites the default parameters used in the process method\n", + " \"no_feature\": specifying a list of columns in the input dataframe that\n", + " should NOT be considered as training features.\n", + " \"target\": the column that is considered as \"target\" in machine learning\n", + " algorithm\n", + " It requires the \"datetime\" column for spliting the data points and adds a\n", + " new column \"signal\" to be used for backtesting.\n", + " The detailed computation steps are listed in the process method's docstring\n", + " \"\"\"\n", + "\n", + " def columns_setup(self):\n", + " self.required = {'datetime': 'datetime64[ms]'}\n", + " self.retention = self.conf['no_feature']\n", + " self.retention['signal'] = 'float64'\n", + "\n", + " def process(self, inputs):\n", + " \"\"\"\n", + " The process is doing following things:\n", + " 1. split the data into training and testing based on provided\n", + " conf['train_date']. If it is not provided, all the data is\n", + " treated as training data.\n", + " 2. train a XGBoost model based on the training data\n", + " 3. Make predictions for all the data points including training and\n", + " testing.\n", + " 4. From the prediction of returns, compute the trading signals that\n", + " can be used in the backtesting.\n", + " Arguments\n", + " -------\n", + " inputs: list\n", + " list of input dataframes.\n", + " Returns\n", + " -------\n", + " dataframe\n", + " \"\"\"\n", + " dxgb_params = {\n", + " 'nround': 100,\n", + " 'max_depth': 8,\n", + " 'max_leaves': 2 ** 8,\n", + " 'alpha': 0.9,\n", + " 'eta': 0.1,\n", + " 'gamma': 0.1,\n", + " 'learning_rate': 0.1,\n", + " 'subsample': 1,\n", + " 'reg_lambda': 1,\n", + " 'scale_pos_weight': 2,\n", + " 'min_child_weight': 30,\n", + " 'tree_method': 'gpu_hist',\n", + " 'n_gpus': 1,\n", + " 'distributed_dask': True,\n", + " 'loss': 'ls',\n", + " # 'objective': 'gpu:reg:linear',\n", + " 'objective': 'reg:squarederror',\n", + " 'max_features': 'auto',\n", + " 'criterion': 'friedman_mse',\n", + " 'grow_policy': 'lossguide',\n", + " 'verbose': True\n", + " }\n", + " if 'xgboost_parameters' in self.conf:\n", + " dxgb_params.update(self.conf['xgboost_parameters'])\n", + " input_df = inputs[0]\n", + " model_df = input_df\n", + " if 'train_date' in self.conf:\n", + " train_date = datetime.datetime.strptime(self.conf['train_date'], # noqa: F841, E501\n", + " '%Y-%m-%d')\n", + " model_df = model_df.query('datetime<@train_date')\n", + " train_cols = set(model_df.columns) - set(\n", + " self.conf['no_feature'].keys())\n", + " train_cols = list(train_cols - set([self.conf['target']]))\n", + " pd_model = model_df.to_pandas()\n", + " train = pd_model[train_cols]\n", + " target = pd_model[self.conf['target']]\n", + " dmatrix = xgb.DMatrix(train, target)\n", + " bst = xgb.train(dxgb_params, dmatrix,\n", + " num_boost_round=dxgb_params['nround'])\n", + " # make inferences\n", + " infer_dmatrix = xgb.DMatrix(input_df.to_pandas()[train_cols])\n", + " prediction = cudf.Series(bst.predict(infer_dmatrix)).astype('float64')\n", + " signal = compute_signal(prediction)\n", + " input_df['signal'] = signal\n", + " # remove the bad datapints\n", + " input_df = input_df.query('signal<10')\n", + " remaining = list(self.conf['no_feature'].keys()) + ['signal']\n", + " return input_df[remaining]\n", + "\n" + ] + } + ], + "source": [ + "import inspect\n", + "from gquant.plugin_nodes import XGBoostStrategyNode\n", + "\n", + "print(inspect.getsource(XGBoostStrategyNode))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### XGBoost Trading Strategy Performance\n", + "Similar to tensorflow, gQuant graph is evaluated by specifying the output nodes and input nodes replacement. We first look at the column result from data preparation node." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output columns of node node_technical_indicator:\n", + "{'BO_BA_b1_10': 'float64',\n", + " 'BO_BA_b2_10': 'float64',\n", + " 'CH_OS_10_20': 'float64',\n", + " 'SHIFT_-1': 'float64',\n", + " 'asset': 'int64',\n", + " 'close': 'float64',\n", + " 'datetime': 'datetime64[ms]',\n", + " 'high': 'float64',\n", + " 'indicator': 'int32',\n", + " 'low': 'float64',\n", + " 'open': 'float64',\n", + " 'returns': 'float64',\n", + " 'volume': 'float64'}\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "\n", + "task_graph.build()\n", + "print('Output columns of node node_technical_indicator:')\n", + "pprint(task_graph['node_technical_indicator'].output_columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It adds the columns \"BO_BA_b1_10\", \"BO_BA_b2_10\", 'CH_OS_10_20\" as features and \"SHFIT_-1\" as the target, which is the return of next day. A good feature should be the one that provides highest information about the next day return. In the case we have no prior information about it,\n", + "we can compute as many features as we like and leave it to the XGBoost to find the right combination of those features. \n", + "\n", + "Evaluate the leaf nodes of the backtesting graph by gQuant `run` method." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cumulative return 5160 17\n", + "cumulative return 1655 5\n" + ] + } + ], + "source": [ + "action = \"load\" if os.path.isfile('./.cache/node_csvdata.hdf5') else \"save\"\n", + "outlist = ['node_sharpe_training','node_cumlativeReturn_training', 'node_sharpe_testing', 'node_cumlativeReturn_testing']\n", + "replace_spec={'node_filterValue': {\"conf\": [{\"column\": \"volume_mean\", \"min\": min_volume},\n", + " {\"column\": \"returns_max\", \"max\": max_rate},\n", + " {\"column\": \"returns_min\", \"min\": min_rate}]},\n", + " 'node_csvdata': {action: True}}\n", + "o_gpu = task_graph.run(\n", + " outputs=outlist + ['node_sort2'],\n", + " replace=replace_spec)\n", + "cached_sort = o_gpu[4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define a function to organized the plot results. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7adb9f003969451eafcfe430ee00009b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(axes=[Axis(label='Cumulative return', orientation='vertical', scale=LinearScale(), side=…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# define the function to format the plots\n", + "def plot_figures(o):\n", + " # format the figures\n", + " figure_width = '1200px'\n", + " figure_height = '400px'\n", + " sharpe_number = o[0]\n", + " cum_return_train = o[1]\n", + " cum_return_train.layout.height = figure_height\n", + " cum_return_train.layout.width = figure_width\n", + " cum_return_train.title = 'Training P & L %.3f' % (sharpe_number)\n", + " sharpe_number = o[2]\n", + " cum_return_test = o[3]\n", + " cum_return_test.layout.height = figure_height\n", + " cum_return_test.layout.width = figure_width\n", + " cum_return_test.title = 'Testing P & L %.3f' % (sharpe_number)\n", + "\n", + " return widgets.VBox([cum_return_train, cum_return_test])\n", + "plot_figures(o_gpu)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clearly, 3 feautres is way too little here. gQuant implmented 36 technical indicators. We can change the configuration of node_technical_indicator node to include more features." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "chaikin_para0 = 10\n", + "chaikin_para1 = 20\n", + "bollinger_para = 10\n", + "macd_para0 = 2\n", + "macd_para1 = 3\n", + "rsi_para0 = 5\n", + "atr_para0 = 10\n", + "sod_para = 2\n", + "mflow_para = 3\n", + "findex_para = 5\n", + "adis_para = 5\n", + "ccindex_para = 5\n", + "bvol_para = 3\n", + "vindex_para = 3\n", + "mindex_para0 = 10\n", + "mindex_para1 = 15\n", + "tindex_para0 = 5\n", + "tindex_para1 = 10\n", + "emove_para = 5\n", + "cc_para = 15\n", + "kchannel_para = 10\n", + "indicator_conf = {\n", + " \"indicators\": [\n", + " {\"function\": \"port_chaikin_oscillator\",\n", + " \"columns\": [\"high\", \"low\", \"close\", \"volume\"],\n", + " \"args\": [chaikin_para0, chaikin_para1]\n", + " },\n", + " {\"function\": \"port_bollinger_bands\",\n", + " \"columns\": [\"close\"],\n", + " \"args\": [bollinger_para],\n", + " \"outputs\": [\"b1\", \"b2\"]\n", + " },\n", + " {\"function\": \"port_macd\",\n", + " \"columns\": [\"close\"],\n", + " \"args\": [macd_para0, macd_para1],\n", + " \"outputs\": [\"MACDsign\", \"MACDdiff\"]\n", + " },\n", + " {\"function\": \"port_relative_strength_index\",\n", + " \"columns\": [\"high\", \"low\"],\n", + " \"args\": [rsi_para0],\n", + " },\n", + " {\"function\": \"port_average_true_range\",\n", + " \"columns\": [\"high\", \"low\", \"close\"],\n", + " \"args\": [atr_para0],\n", + " },\n", + " {\"function\": \"port_stochastic_oscillator_k\",\n", + " \"columns\": [\"high\", \"low\", \"close\"],\n", + " \"args\": [],\n", + " },\n", + " {\"function\": \"port_stochastic_oscillator_d\",\n", + " \"columns\": [\"high\", \"low\", \"close\"],\n", + " \"args\": [sod_para],\n", + " },\n", + " {\"function\": \"port_money_flow_index\",\n", + " \"columns\": [\"high\", \"low\", \"close\", \"volume\"],\n", + " \"args\": [mflow_para],\n", + " },\n", + " {\"function\": \"port_force_index\",\n", + " \"columns\": [\"close\", \"volume\"],\n", + " \"args\": [findex_para],\n", + " },\n", + " {\"function\": \"port_ultimate_oscillator\",\n", + " \"columns\": [\"high\",\"low\",\"close\"],\n", + " \"args\": [],\n", + " },\n", + " {\"function\": \"port_accumulation_distribution\",\n", + " \"columns\": [\"high\",\"low\",\"close\",\"volume\"],\n", + " \"args\": [adis_para],\n", + " },\n", + " {\"function\": \"port_commodity_channel_index\",\n", + " \"columns\": [\"high\",\"low\",\"close\"],\n", + " \"args\": [ccindex_para],\n", + " },\n", + " {\"function\": \"port_on_balance_volume\",\n", + " \"columns\": [\"close\", \"volume\"],\n", + " \"args\": [bvol_para],\n", + " },\n", + " {\"function\": \"port_vortex_indicator\",\n", + " \"columns\": [\"high\", \"low\", \"close\"],\n", + " \"args\": [vindex_para],\n", + " },\n", + " {\"function\": \"port_kst_oscillator\",\n", + " \"columns\": [\"close\"],\n", + " \"args\": [3, 4, 5, 6, 7, 8, 9, 10],\n", + " },\n", + " {\"function\": \"port_mass_index\",\n", + " \"columns\": [\"high\", \"low\"],\n", + " \"args\": [mindex_para0, mindex_para1],\n", + " },\n", + " {\"function\": \"port_true_strength_index\",\n", + " \"columns\": [\"close\"],\n", + " \"args\": [tindex_para0, tindex_para1],\n", + " },\n", + " {\"function\": \"port_ease_of_movement\",\n", + " \"columns\": [\"high\", \"low\", \"volume\"],\n", + " \"args\": [emove_para],\n", + " },\n", + " {\"function\": \"port_coppock_curve\",\n", + " \"columns\": [\"close\"],\n", + " \"args\": [cc_para],\n", + " },\n", + " {\"function\": \"port_keltner_channel\",\n", + " \"columns\": [\"high\", \"low\", \"close\"],\n", + " \"args\": [kchannel_para],\n", + " \"outputs\": [\"KelChD\", \"KelChM\", \"KelChU\"]\n", + " },\n", + " {\"function\": \"port_ppsr\",\n", + " \"columns\": [\"high\", \"low\", \"close\"],\n", + " \"args\": [],\n", + " \"outputs\": [\"PP\", \"R1\", \"S1\", \"R2\", \"S2\", \"R3\", \"S3\"]\n", + " },\n", + " {\"function\": \"port_shift\",\n", + " \"columns\": [\"returns\"],\n", + " \"args\": [-1]\n", + " } \n", + " ],\n", + " \"remove_na\": True\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run the backtesting again" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cumulative return 5063 16\n", + "cumulative return 1606 5\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "01943413ff7c46569fc4f641ec183ba3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Figure(axes=[Axis(label='Cumulative return', orientation='vertical', scale=LinearScale()), Axis…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "replace_spec['node_technical_indicator'] = {\"conf\": indicator_conf}\n", + "replace_spec['node_sort2'] = {\"load\": cached_sort}\n", + "o_gpu = task_graph.run(\n", + " outputs=outlist,\n", + " replace=replace_spec)\n", + "plot_figures(o_gpu)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We get Sharpe Raio of `1.93` in the testing dataset, not bad!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Strategy parameter search\n", + "Quantitative analyst usually need to explore different parameters for their trading strategy. The exploration process is an iterative process. gQuant help to speed up this by allowing using cached dataframe and evaluating the sub-graphs.\n", + "\n", + "To find the optimal technical indicator parameters for this XGBoost strategy, we build a wiget to search the parameter interactively. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "77490bff5a264eac9beff3219bd8999d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(VBox(children=(IntRangeSlider(value=(10, 20), continuous_update=False, description='Chaikin', m…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import plotutils\n", + "plotutils.getXGBoostWidget(replace_spec, task_graph, outlist, plot_figures)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conclusions\n", + "In this notebook, we demoed how to use gQuant to backtest XGBoost trading strategy. It is convenient and efficient to use indicator node from the gQuant to compute features for all the stocks in the dataset in the GPU. The XGBoost training are computed in the GPU, so we can get the results quickly. This example shows the XGBoost algorithm's power in finding trading signals. We can achieve close to 2 raw Sharpe ratio in the testing time period." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebook/cuIndicator/indicator_demo.ipynb b/notebook/cuIndicator/indicator_demo.ipynb index ffa8d477..b8fc8549 100644 --- a/notebook/cuIndicator/indicator_demo.ipynb +++ b/notebook/cuIndicator/indicator_demo.ipynb @@ -1,28 +1,32 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Technical Indicators Demo\n", + "\n", + "## Download example datasets\n", + "\n", + "Before getting started, let's download the example datasets if not present." + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset is already present. No need to re-download it.\n" + ] + } + ], "source": [ - "import sys\n", - "sys.path.append('../..')\n", - "import pandas as pd\n", - "import cudf\n", - "import numpy as np\n", - "import gquant.cuindicator as ci\n", - "from bqplot.traits import convert_to_date\n", - "import bqplot.pyplot as plt\n", - "import ipywidgets as widgets\n", - "from IPython.display import display\n", - "import datetime\n", - "import math\n", - "from bqplot import OHLC, LinearScale, DateScale, Axis, Figure, Bars, CATEGORY10, OrdinalScale, Lines, Tooltip\n", - "from bqplot.colorschemes import CATEGORY20\n", - "from gquant.dataframe_flow import run, load_workflow, viz_graph\n", - "import nxpd\n", - "from nxpd import draw" + "! ((test ! -f '../data/stock_price_hist.csv.gz' || test ! -f '../data/security_master.csv.gz') && \\\n", + " cd ../.. && bash download_data.sh) || echo \"Dataset is already present. No need to re-download it.\"" ] }, { @@ -31,49 +35,64 @@ "metadata": {}, "outputs": [], "source": [ - "node_csv = {\"id\": \"node_csvdata\",\n", - " \"type\": \"CsvStockLoader\",\n", - " \"conf\": {\n", - " \"path\": \"/Project/data/stocks/stock_price_hist.csv.gz\" \n", - " },\n", - " \"inputs\": []}\n", - "node_asset = {\"id\": \"node_assetFilter\",\n", - " \"type\": \"AssetFilterNode\",\n", - " \"conf\": {\n", - " \"asset\": 22123 \n", - " },\n", - " \"inputs\": [\"node_csvdata\"]}\n", - "node_sort = {\"id\": \"node_sort\",\n", - " \"type\": \"SortNode\",\n", - " \"conf\": {\n", - " \"keys\": ['asset', 'datetime']\n", - " },\n", - " \"inputs\": [\"node_csvdata\"]\n", - " }\n", - "node_stockSymbol = {\"id\": \"node_stockSymbol\",\n", - " \"type\": \"StockNameLoader\",\n", - " \"conf\": {\n", - " \"path\": \"/Project/data/stocks/security_master.csv.gz\" \n", - " },\n", - " \"inputs\": []} " + "from bqplot import OHLC, LinearScale, DateScale, Axis, Figure, Bars, Lines, Tooltip\n", + "from bqplot.colorschemes import CATEGORY20\n", + "import datetime\n", + "import ipywidgets as widgets\n", + "import numpy as np\n", + "import pandas as pd" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/conda/envs/rapids/lib/python3.6/site-packages/cudf-0.7.2-py3.6-linux-x86_64.egg/cudf/io/hdf.py:13: UserWarning: Using CPU via Pandas to read HDF dataset, this may be GPU accelerated in the future\n", - " warnings.warn(\"Using CPU via Pandas to read HDF dataset, this may \"\n" - ] - } - ], + "outputs": [], "source": [ - "df = run([node_csv, node_sort], ['node_sort'], {'node_csvdata': {\"load\": True}})[0]\n", + "import sys; sys.path.append('../..')\n", + "\n", + "from gquant.dataframe_flow import TaskSpecSchema\n", + "\n", + "\n", + "task_load_csv_data = {\n", + " TaskSpecSchema.task_id: \"load_csv_data\",\n", + " TaskSpecSchema.node_type: \"CsvStockLoader\",\n", + " TaskSpecSchema.conf: {\"path\": \"../data/stock_price_hist.csv.gz\"},\n", + " TaskSpecSchema.inputs: []\n", + "}\n", + "\n", + "task_sort = {\n", + " TaskSpecSchema.task_id: \"sort\",\n", + " TaskSpecSchema.node_type: \"SortNode\",\n", + " TaskSpecSchema.conf: {\"keys\": ['asset', 'datetime']},\n", + " TaskSpecSchema.inputs: [\"load_csv_data\"]\n", + "}\n", + "\n", + "task_stock_symbol = {\n", + " TaskSpecSchema.task_id: \"stock_symbol\",\n", + " TaskSpecSchema.node_type: \"StockNameLoader\",\n", + " TaskSpecSchema.conf: {\"path\": \"../data/security_master.csv.gz\"},\n", + " TaskSpecSchema.inputs: []\n", + "} " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import warnings; warnings.simplefilter(\"ignore\")\n", + "\n", + "from gquant.dataframe_flow import TaskGraph\n", + "\n", + "task_list = [task_load_csv_data, task_sort]\n", + "task_graph = TaskGraph(task_list)\n", + "\n", + "action = \"load\" if os.path.isfile('./.cache/load_csv_data.hdf5') else \"save\"\n", + "\n", + "df = task_graph.run(outputs=['sort'], replace={'load_csv_data': {action: True}})[0]\n", "\n", "def one_stock(df, stock_id):\n", " return df.query('asset==%s' % stock_id)\n", @@ -83,15 +102,20 @@ " end_date = datetime.datetime.strptime(str(int(year)+1)+'-01-01', '%Y-%m-%d')\n", " return df.query('datetime<@end_date and datetime>=@beg_date')\n", "\n", - "indicator_lists = ['MA', 'EWA', 'Chaikin Oscillator', 'Average Directional Movement Index', 'MACD', 'TRIX', 'RSI',\n", - " 'Bollinger Bands','Commodity Channel Index','Parabolic SAR','Rate of Change','Average True Range',\n", - " 'Stochastic Oscillator D','Vortex Indicator','Mass Index','True Strength Index','Money Flow Index', \n", - " 'On Balance Volume','Force Index','Ease of Movement','Donchian Channel','Keltner Channel', 'Coppock Curve',\n", - " 'Accumulation Distribution','Momentum','Ultimate Oscillator','Stochastic Oscillator K','KST Oscillator']\n", - "list_stocks = run([node_stockSymbol], ['node_stockSymbol'])[0].to_pandas().set_index('asset_name').to_dict()['asset']\n", + "indicator_lists = ['Accumulation Distribution', 'ADMI', 'Average True Range', 'Bollinger Bands',\n", + " 'Chaikin Oscillator', 'Commodity Channel Index', 'Coppock Curve', 'Donchian Channel',\n", + " 'Ease of Movement', 'EWA', 'Force Index', 'Keltner Channel', 'KST Oscillator', 'MA', 'MACD',\n", + " 'Mass Index', 'Momentum', 'Money Flow Index', 'On Balance Volume', 'Parabolic SAR',\n", + " 'Rate of Change', 'RSI', 'Stochastic Oscillator D', 'Stochastic Oscillator K', 'TRIX',\n", + " 'True Strength Index', 'Ultimate Oscillator', 'Vortex Indicator',]\n", + "\n", + "task_stocks_list = [task_stock_symbol]\n", + "task_stocks_graph = TaskGraph(task_stocks_list)\n", + "list_stocks = task_stocks_graph.run(outputs=['stock_symbol'])[0].to_pandas().set_index('asset_name').to_dict()['asset']\n", + "\n", "main_figure_height='300px'\n", - "indicator_figure_height='150px'\n", - "figure_width = '1500px'" + "indicator_figure_height='200px'\n", + "figure_width = '1000px'" ] }, { @@ -104,7 +128,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "53c64e5d71db4650ba3ecc55e9990098", + "model_id": "1d31820ab4e14569bd0f0f7e9feab2b9", "version_major": 2, "version_minor": 0 }, @@ -120,6 +144,7 @@ "add_stock_selector = widgets.Dropdown(options=list_stocks.keys(), value=None, description=\"Add stock\")\n", "year_selector = widgets.IntSlider(description=\"All Year\", continuous_update=False)\n", "year_selectors = []\n", + "\n", "def get_figure(selected, df):\n", " this_stock = one_stock(df, list_stocks[selected])\n", " this_stock_store = [this_stock]\n", @@ -176,7 +201,6 @@ " def year_selection(*stock):\n", " stock = slice_stock(this_stock_store[0], year_selector.value)\n", " update_graph(stock)\n", - " \n", " \n", " def stock_selection(*stock):\n", " this_stock_store[0] = one_stock(df, list_stocks[stock_selector.value])\n", @@ -186,7 +210,7 @@ " ohlc.labels = [stock_selector.value]\n", " update_graph(stock)\n", " \n", - " def update_figure(stock, objects):\n", + " def update_figure_(stock, objects):\n", " line = objects[0]\n", " with line.hold_trait_notifications():\n", " line.y = stock['out']\n", @@ -211,10 +235,10 @@ " def indicator_selection(*stock):\n", " if indicator_selector.value is None:\n", " return\n", + " \n", " color_id[0] = (color_id[0] + 1) % len(CATEGORY20)\n", " \n", " def setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun):\n", - "\n", " with out: \n", " def update_df(para_selector_widgets):\n", " my_stock = this_stock_store[0]\n", @@ -226,7 +250,9 @@ " para_selector_widgets = get_para_widgets() \n", " para_selectors.children += tuple(para_selector_widgets) \n", " stock = update_df(para_selector_widgets)\n", - " figs = create_figure(stock)\n", + " figs = create_figure(stock=stock, dt_scale=dt_scale, sc=sc, color_id=color_id, f=f, \n", + " indicator_figure_height=indicator_figure_height, figure_width=figure_width,\n", + " add_new_indicator=add_new_indicator)\n", "\n", " def update_para(*para):\n", " stock = update_df(para_selector_widgets)\n", @@ -236,1012 +262,102 @@ " selector.observe(update_para, 'value')\n", " year_selector.observe(update_para, 'value')\n", " stock_selector.observe(update_para, 'value')\n", - " \n", - " if indicator_selector.value=='MA':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"avg periods\")\n", - " para_selector_widgets = [para_selector]\n", - " \n", - " return para_selector_widgets\n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"close\"],) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = stock_df['out'].fillna(math.inf)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc}, colors=[CATEGORY20[color_id[0]]])\n", - " figs = [line]\n", - " f.marks = f.marks + figs\n", - " return figs\n", - " \n", - " indicator_fun = ci.moving_average \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " elif indicator_selector.value=='EWA':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"ewa avg periods\")\n", - " para_selector_widgets = [para_selector] \n", - " return para_selector_widgets\n", + " with out:\n", + " update_figure = update_figure_\n", + " if indicator_selector.value=='Accumulation Distribution':\n", + " from viz.accumulation_distribution import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun \n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"close\"],) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = stock_df['out'].fillna(math.inf)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc}, colors=[CATEGORY20[color_id[0]]])\n", - " figs = [line]\n", - " f.marks = f.marks + figs\n", - " return figs\n", - " \n", - " indicator_fun = ci.exponential_moving_average \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " elif indicator_selector.value=='Chaikin Oscillator':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntRangeSlider(value=[10, 30],\n", - " min=3,\n", - " max=60,\n", - " step=1,\n", - " description=\"Ch Oscillator:\",\n", - " disabled=False,\n", - " continuous_update=False,\n", - " orientation='horizontal',\n", - " readout=True)\n", - " para_selector_widgets = [para_selector] \n", - " return para_selector_widgets\n", + " elif indicator_selector.value=='ADMI':\n", + " from viz.admi import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " widget = para_selector_widgets[0]\n", - " return (stock_df[\"high\"], stock_df[\"low\"], stock_df[\"close\"], stock_df[\"volume\"], widget.value[0], widget.value[1])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = stock_df['out'].fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Ch Osc', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig) \n", - " return figs\n", - " \n", - " indicator_fun = ci.chaikin_oscillator \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " elif indicator_selector.value=='Average Directional Movement Index':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntRangeSlider(value=[10, 30],\n", - " min=3,\n", - " max=60,\n", - " step=1,\n", - " description=\"ADMI:\",\n", - " disabled=False,\n", - " continuous_update=False,\n", - " orientation='horizontal',\n", - " readout=True)\n", - " para_selector_widgets = [para_selector] \n", - " return para_selector_widgets\n", + " elif indicator_selector.value=='Average True Range':\n", + " from viz.average_true_range import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " widget = para_selector_widgets[0]\n", - " return (stock_df[\"high\"], stock_df[\"low\"], stock_df[\"close\"], widget.value[0], widget.value[1])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = stock_df['out'].fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='ADMI', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig) \n", - " return figs\n", - " \n", - " indicator_fun = ci.average_directional_movement_index \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun) \n", - " elif indicator_selector.value=='MACD':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntRangeSlider(value=[10, 30],\n", - " min=3,\n", - " max=60,\n", - " step=1,\n", - " description=\"MACD:\",\n", - " disabled=False,\n", - " continuous_update=False,\n", - " orientation='horizontal',\n", - " readout=True)\n", - " para_selector_widgets = [para_selector] \n", - " return para_selector_widgets\n", + " elif indicator_selector.value=='Bollinger Bands':\n", + " from viz.bollinger_bands import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun, update_figure\n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " widget = para_selector_widgets[0]\n", - " return (stock_df[\"close\"], widget.value[0], widget.value[1])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out0'] = output.MACD\n", - " stock_df['out0'] = stock_df['out0'].fillna(0)\n", - " stock_df['out1'] = output.MACDsign\n", - " stock_df['out1'] = stock_df['out1'].fillna(0)\n", - " stock_df['out2'] = output.MACDdiff\n", - " stock_df['out2'] = stock_df['out2'].fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='MACD', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=[stock['out0'], stock['out1'], stock['out2'] ], scales={'x': dt_scale, 'y': sc_co}) #\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig) \n", - " return figs\n", - " \n", - " def up_figure(stock, objects):\n", - " line = objects[0]\n", - " with line.hold_trait_notifications():\n", - " line.y = [stock['out0'], stock['out1'], stock['out2']]\n", - " line.x = stock.datetime \n", - " \n", - " indicator_fun = ci.macd \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, up_figure, indicator_fun)\n", - " elif indicator_selector.value=='TRIX':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"TRIX\")\n", - " para_selector_widgets = [para_selector] \n", - " return para_selector_widgets\n", + " elif indicator_selector.value=='Chaikin Oscillator':\n", + " from viz.ch_oscillator import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"close\"],) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = stock_df['out'].fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='TRIX', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", + " elif indicator_selector.value=='Commodity Channel Index':\n", + " from viz.commodity_channel_index import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", "\n", - " \n", - " indicator_fun = ci.exponential_moving_average \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " elif indicator_selector.value=='RSI':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"RSI\")\n", - " para_selector_widgets = [para_selector] \n", - " return para_selector_widgets\n", + " elif indicator_selector.value=='Coppock Curve':\n", + " from viz.coppock_curve import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun \n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"], stock_df[\"low\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = stock_df['out'].fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='RSI', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", + " elif indicator_selector.value=='Donchian Channel':\n", + " from viz.donchian_channel import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun \n", "\n", - " \n", - " indicator_fun = ci.relative_strength_index \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Bollinger Bands':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Bollinger Bands\")\n", - " para_selector_widgets = [para_selector] \n", - " return para_selector_widgets\n", + " elif indicator_selector.value=='Ease of Movement':\n", + " from viz.ease_of_movement import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun \n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"close\"],) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out0'] = output.b1\n", - " stock_df['out0'] = stock_df['out0'].fillna(0)\n", - " stock_df['out1'] = output.b2\n", - " stock_df['out1'] = stock_df['out1'].fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " sc_co2 = LinearScale()\n", - " ax_y = Axis(label='Bollinger b1', scale=sc_co, orientation='vertical')\n", - " ax_y2 = Axis(label='Bollinger b2', scale=sc_co2, orientation='vertical', side='right')\n", - " new_line = Lines(x=stock.datetime, y=stock['out0'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) \n", - " new_line2 = Lines(x=stock.datetime, y=stock['out1'], scales={'x': dt_scale, 'y': sc_co2}, colors=[CATEGORY20[(color_id[0] + 1) % len(CATEGORY20)]]) \n", - " new_fig = Figure(marks=[new_line, new_line2], axes=[ax_y, ax_y2])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line, new_line2]\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " def up_figure(stock, objects):\n", - " line = objects[0]\n", - " line2 = objects[1]\n", - " with line.hold_trait_notifications() as lc, line2.hold_trait_notifications() as lc2:\n", - " line.y = stock['out0']\n", - " line.x = stock.datetime \n", - " line2.y = stock['out1']\n", - " line2.x = stock.datetime \n", - " \n", - " indicator_fun = ci.bollinger_bands \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, up_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Commodity Channel Index':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Commodity Channel Index\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " #print ((stock_df[\"high\"],stock_df[\"low\"], stock_df[\"close\"]) + tuple([w.value for w in para_selector_widgets]))\n", - " return (stock_df[\"high\"],stock_df[\"low\"], stock_df[\"close\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='CCI', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.commodity_channel_index \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Parabolic SAR':\n", - " with out:\n", - " def get_para_widgets():\n", - " #para_selector = widgets.IntSlider(min=2, max=60, description=\"Parabolic SAR\")\n", - " para_selector_widgets = []\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df,para_selector_widgets):\n", - " return (stock_df[\"high\"], stock_df[\"low\"], stock_df[\"close\"]) \n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out0'] = output.PP\n", - " stock_df['out0'] = stock_df['out0'].fillna(0)\n", - " stock_df['out1'] = output.R1\n", - " stock_df['out1'] = stock_df['out1'].fillna(0)\n", - " stock_df['out2'] = output.S1\n", - " stock_df['out2'] = stock_df['out2'].fillna(0)\n", - " stock_df['out3'] = output.R2\n", - " stock_df['out3'] = stock_df['out3'].fillna(0)\n", - " stock_df['out4'] = output.S2\n", - " stock_df['out4'] = stock_df['out4'].fillna(0)\n", - " stock_df['out5'] = output.R3\n", - " stock_df['out5'] = stock_df['out5'].fillna(0)\n", - " stock_df['out6'] = output.S3\n", - " stock_df['out6'] = stock_df['out6'].fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " sc_co2 = LinearScale()\n", - " sc_co3 = LinearScale()\n", - " sc_co4 = LinearScale()\n", - " sc_co5 = LinearScale()\n", - " sc_co6 = LinearScale()\n", - " sc_co7 = LinearScale()\n", - " \n", - " ax_y = Axis(label='PPSR PP', scale=sc_co, orientation='vertical')\n", - " ax_y2 = Axis(label='PPSR R1', scale=sc_co2, orientation='vertical', side='right')\n", - " ax_y3 = Axis(label='PPSR S1', scale=sc_co3, orientation='vertical', side='right')\n", - " ax_y4 = Axis(label='PPSR R2', scale=sc_co4, orientation='vertical', side='right')\n", - " ax_y5 = Axis(label='PPSR S2', scale=sc_co5, orientation='vertical', side='right')\n", - " ax_y6 = Axis(label='PPSR R3', scale=sc_co6, orientation='vertical', side='right')\n", - " ax_y7 = Axis(label='PPSR S3', scale=sc_co7, orientation='vertical', side='right')\n", - " new_line = Lines(x=stock.datetime, y=stock['out0'], scales={'x': dt_scale, 'y': sc_co}, \n", - " colors=[CATEGORY20[color_id[0]]]) \n", - " new_line2 = Lines(x=stock.datetime, y=stock['out1'], scales={'x': dt_scale, 'y': sc_co2}, \n", - " colors=[CATEGORY20[(color_id[0] + 1) % len(CATEGORY20)]]) \n", - " new_line3 = Lines(x=stock.datetime, y=stock['out2'], scales={'x': dt_scale, 'y': sc_co3}, \n", - " colors=[CATEGORY20[(color_id[0] + 2) % len(CATEGORY20)]])\n", - " new_line4 = Lines(x=stock.datetime, y=stock['out3'], scales={'x': dt_scale, 'y': sc_co4}, \n", - " colors=[CATEGORY20[(color_id[0] + 3) % len(CATEGORY20)]]) \n", - " new_line5 = Lines(x=stock.datetime, y=stock['out4'], scales={'x': dt_scale, 'y': sc_co5}, \n", - " colors=[CATEGORY20[(color_id[0] + 4) % len(CATEGORY20)]]) \n", - " new_line6 = Lines(x=stock.datetime, y=stock['out5'], scales={'x': dt_scale, 'y': sc_co6}, \n", - " colors=[CATEGORY20[(color_id[0] + 5) % len(CATEGORY20)]]) \n", - " new_line7 = Lines(x=stock.datetime, y=stock['out6'], scales={'x': dt_scale, 'y': sc_co7}, \n", - " colors=[CATEGORY20[(color_id[0] + 6) % len(CATEGORY20)]]) \n", - " \n", - " \n", - " new_fig = Figure(marks=[new_line, new_line2, new_line3, new_line4, \n", - " new_line5, new_line6, new_line7], \n", - " axes=[ax_y, ax_y2, ax_y3, ax_y4, ax_y5, ax_y6, ax_y7])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line, new_line2, new_line3, new_line4, new_line5, new_line6, new_line7]\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " def up_figure(stock, objects):\n", - " line = objects[0]\n", - " line2 = objects[1]\n", - " with line.hold_trait_notifications() as lc, line2.hold_trait_notifications() as lc2:\n", - " line.y = stock['out0']\n", - " line.x = stock.datetime \n", - " line2.y = stock['out1']\n", - " line2.x = stock.datetime \n", - " \n", - " indicator_fun = ci.ppsr \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, up_figure, indicator_fun)\n", - " \n", - " \n", - " elif indicator_selector.value=='Rate of Change':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Rate of Change\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"close\"],) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " print(stock_df['out'])\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Rate of Change', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.rate_of_change \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Average True Range':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Rate of Change\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"],stock_df[\"low\"], stock_df[\"close\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Average True Range', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.average_true_range \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Stochastic Oscillator D':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Stochastic Oscillator D\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"],stock_df[\"low\"], stock_df[\"close\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Stochastic Oscillator D', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.stochastic_oscillator_d \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Vortex Indicator':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Vortex Indicator\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"],stock_df[\"low\"], stock_df[\"close\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Vortex Indicator', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.vortex_indicator \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " \n", - " elif indicator_selector.value=='Mass Index':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntRangeSlider(value=[10, 30],\n", - " min=3,\n", - " max=60,\n", - " step=1,\n", - " description=\"Mass Index:\",\n", - " disabled=False,\n", - " continuous_update=False,\n", - " orientation='horizontal',\n", - " readout=True)\n", - " para_selector_widgets = [para_selector] \n", - " return para_selector_widgets\n", + " elif indicator_selector.value=='EWA':\n", + " from viz.ewa import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " widget = para_selector_widgets[0]\n", - " return (stock_df[\"high\"], stock_df[\"low\"], widget.value[0], widget.value[1])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = stock_df['out'].fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Mass Index', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig) \n", - " return figs\n", - " \n", - " indicator_fun = ci.mass_index \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='True Strength Index':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntRangeSlider(value=[10, 30],\n", - " min=3,\n", - " max=60,\n", - " step=1,\n", - " description=\"True Strength Index\",\n", - " disabled=False,\n", - " continuous_update=False,\n", - " orientation='horizontal',\n", - " readout=True)\n", - " para_selector_widgets = [para_selector] \n", - " return para_selector_widgets\n", + " elif indicator_selector.value=='Force Index':\n", + " from viz.force_index import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", "\n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " widget = para_selector_widgets[0]\n", - " return (stock_df[\"close\"],widget.value[0], widget.value[1])\n", - " \n", - " def process_outputs(output, stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = stock_df['out'].fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='True Strength Index', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig) \n", - " return figs\n", - " \n", - " indicator_fun = ci.true_strength_index \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Money Flow Index':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Money Flow Index\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"],stock_df[\"low\"], stock_df[\"close\"], stock_df[\"volume\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Money Flow Index', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.money_flow_index \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " \n", - " elif indicator_selector.value=='On Balance volume':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"On Balance volume\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"close\"], stock_df[\"volume\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='On Balance volume', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.on_balance_volume \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " \n", - " elif indicator_selector.value=='Force Index':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Force Index\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"close\"], stock_df[\"volume\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Force Index', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.force_index \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Ease of Movement':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Ease of Movement\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"], stock_df[\"low\"], stock_df[\"volume\"])\n", - " + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Ease of Movement', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.ease_of_movement \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " \n", - " elif indicator_selector.value=='Donchian Channel':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Donchian Channel\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"], stock_df[\"low\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Donchian Channel', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.donchian_channel \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " \n", - " elif indicator_selector.value=='Keltner Channel':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Keltner Channel\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"], stock_df[\"low\"], stock_df[\"close\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Keltner Channel', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.keltner_channel \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Coppock Curve':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Coppock Curve\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"close\"],) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Coppock Curve', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.coppock_curve \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " \n", - " elif indicator_selector.value=='Accumulation Distribution':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Accumulation Distribution\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"], stock_df[\"low\"], stock_df[\"close\"], stock_df[\"volume\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Accumulation Distribution', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.accumulation_distribution \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Accumulation Distribution':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Accumulation Distribution\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"], stock_df[\"low\"], stock_df[\"close\"], stock_df[\"volume\"]) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Accumulation Distribution', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.accumulation_distribution \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Momentum':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"Momentum\")\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"close\"],) + tuple([w.value for w in para_selector_widgets])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Momentum', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.momentum \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " elif indicator_selector.value=='Ultimate Oscillator':\n", - " with out:\n", - " def get_para_widgets():\n", - " #para_selector = widgets.IntSlider(min=2, max=60, description=\"Ultimate Oscillator\")\n", - " para_selector_widgets = []\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"], stock_df[\"low\"], stock_df[\"close\"]) \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Ultimate Oscillator', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.ultimate_oscillator\n", - " setup_indicator(get_para_widgets,get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " \n", - " elif indicator_selector.value=='Stochastic Oscillator K':\n", - " with out:\n", - " def get_para_widgets():\n", - " #para_selector = widgets.IntSlider(min=2, max=60, description=\"Ultimate Oscillator\")\n", - " para_selector_widgets = []\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " return (stock_df[\"high\"], stock_df[\"low\"], stock_df[\"close\"]) \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='Stochastic Oscillator K', scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", - " \n", - " indicator_fun = ci.stochastic_oscillator_k\n", - " setup_indicator(get_para_widgets,get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", - " \n", - " \n", - " \n", - " elif indicator_selector.value=='KST Oscillator':\n", - " with out:\n", - " def get_para_widgets():\n", - " para_selector = widgets.IntSlider(min=2, max=60, description=\"KST Oscillator\")\n", - " #para_selector_widgets = []\n", - " para_selector_widgets = [para_selector]\n", - " return para_selector_widgets\n", - " \n", - " def get_parameters(stock_df, para_selector_widgets):\n", - " param = [w.value for w in para_selector_widgets]\n", - " print (param)\n", - " param_grp = [param[0] + i for i in range(8)]\n", - " #param_grp = np.array(param_grp)\n", - " print (param_grp)\n", - " #return (stock_df[\"close\"], 3,4,5,6,7,8,9,10)\n", - " return (stock_df[\"close\"],param_grp[0],param_grp[1],param_grp[2],param_grp[3],\n", - " param_grp[4],param_grp[5],param_grp[6],param_grp[7])\n", - " \n", - " def process_outputs(output,stock_df):\n", - " stock_df['out'] = output\n", - " stock_df['out'] = output.fillna(0)\n", - " return stock_df\n", - " \n", - " def create_figure(stock):\n", - " sc_co = LinearScale()\n", - " ax_y = Axis(label='KST Oscillator',scale=sc_co, orientation='vertical')\n", - " new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]])\n", - " new_fig = Figure(marks=[new_line], axes=[ax_y])\n", - " new_fig.layout.height = indicator_figure_height\n", - " new_fig.layout.width = figure_width \n", - " figs = [new_line]\n", - " # add new figure\n", - " add_new_indicator(new_fig)\n", - " return figs\n", + " elif indicator_selector.value=='Keltner Channel':\n", + " from viz.keltner_channel import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun \n", + "\n", + " elif indicator_selector.value=='KST Oscillator':\n", + " from viz.kst_oscillator import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " elif indicator_selector.value=='MA':\n", + " from viz.ma import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " elif indicator_selector.value=='MACD': \n", + " from viz.macd import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun, update_figure\n", + "\n", + " elif indicator_selector.value=='Mass Index':\n", + " from viz.mass_index import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + " elif indicator_selector.value=='Momentum':\n", + " from viz.momentum import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " elif indicator_selector.value=='Money Flow Index':\n", + " from viz.money_flow_index import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " elif indicator_selector.value=='On Balance volume':\n", + " from viz.on_balance_volume import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " elif indicator_selector.value=='Parabolic SAR':\n", + " from viz.parabolic_sar import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun, update_figure\n", + "\n", + " elif indicator_selector.value=='Rate of Change':\n", + " from viz.rate_of_change import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " elif indicator_selector.value=='RSI':\n", + " from viz.rsi import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " elif indicator_selector.value=='Stochastic Oscillator D':\n", + " from viz.stochastic_oscillator_d import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " elif indicator_selector.value=='Stochastic Oscillator K':\n", + " from viz.stochastic_oscillator_k import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun \n", + "\n", + " elif indicator_selector.value=='TRIX':\n", + " from viz.trix import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " elif indicator_selector.value=='True Strength Index':\n", + " from viz.true_strength_index import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun \n", + "\n", + " elif indicator_selector.value=='Ultimate Oscillator':\n", + " from viz.ultimate_oscillator import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun \n", " \n", - " indicator_fun = ci.kst_oscillator \n", - " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", + " elif indicator_selector.value=='Vortex Indicator':\n", + " from viz.vortex_indicator import get_para_widgets, get_parameters, process_outputs, create_figure, indicator_fun\n", + "\n", + " setup_indicator(get_para_widgets, get_parameters, process_outputs, create_figure, update_figure, indicator_fun)\n", + "\n", " indicator_selector.value=None\n", - " \n", - " \n", - " \n", + "\n", " year_selector.observe(year_selection, 'value')\n", " stock_selector.observe(stock_selection, 'value')\n", " indicator_selector.observe(indicator_selection, 'value')\n", " multiple_figs = widgets.VBox([f])\n", " return multiple_figs, year_selector, stock_selector, indicator_selector, para_selectors\n", "\n", - "#f, year_selector, stock_selector, indicator_selector, para_selectors = get_figure(add_stock_selector.value, df)\n", - "\n", "def stock_selection(*stock):\n", " if add_stock_selector.value is None:\n", " return\n", @@ -1280,70 +396,6 @@ "w = widgets.VBox([selectors, widgets.VBox([])])\n", "w" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": false - }, - "outputs": [], - "source": [ - "output = ci.ppsr(df['High'],df['Low'],df['Close'])\n", - "print (output)\n", - "print(output.R1)\n", - "#print (output[100:].fillna(0))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "param_grp = [3 + i for i in range(8)]\n", - "print (param_grp)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "get_parameters(stock_df)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0bdf2053c4664866af48e1a060fc02af", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Output(layout=Layout(border='1px solid black'))" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "out" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/notebook/cuIndicator/viz/__init__.py b/notebook/cuIndicator/viz/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/notebook/cuIndicator/viz/accumulation_distribution.py b/notebook/cuIndicator/viz/accumulation_distribution.py new file mode 100644 index 00000000..a97106a0 --- /dev/null +++ b/notebook/cuIndicator/viz/accumulation_distribution.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import accumulation_distribution as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Accumulation Distribution") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"], stock_df["low"], stock_df["close"], stock_df["volume"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Accumulation Distribution', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/admi.py b/notebook/cuIndicator/viz/admi.py new file mode 100644 index 00000000..ea7e6fe6 --- /dev/null +++ b/notebook/cuIndicator/viz/admi.py @@ -0,0 +1,39 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import average_directional_movement_index as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntRangeSlider(value=[10, 30], + min=3, + max=60, + step=1, + description="ADMI:", + disabled=False, + continuous_update=False, + orientation='horizontal', + readout=True) + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + widget = para_selector_widgets[0] + return (stock_df["high"], stock_df["low"], stock_df["close"], widget.value[0], widget.value[1]) + +def process_outputs(output, stock_df): + stock_df['out'] = output + stock_df['out'] = stock_df['out'].fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='ADMI', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs diff --git a/notebook/cuIndicator/viz/average_true_range.py b/notebook/cuIndicator/viz/average_true_range.py new file mode 100644 index 00000000..711ac0ef --- /dev/null +++ b/notebook/cuIndicator/viz/average_true_range.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import average_true_range as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Average True Range") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"],stock_df["low"], stock_df["close"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Average True Range', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/bollinger_bands.py b/notebook/cuIndicator/viz/bollinger_bands.py new file mode 100644 index 00000000..d23d1b4b --- /dev/null +++ b/notebook/cuIndicator/viz/bollinger_bands.py @@ -0,0 +1,43 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import bollinger_bands as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Bollinger Bands") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["close"],) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output, stock_df): + stock_df['out0'] = output.b1 + stock_df['out0'] = stock_df['out0'].fillna(0) + stock_df['out1'] = output.b2 + stock_df['out1'] = stock_df['out1'].fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + sc_co2 = LinearScale() + ax_y = Axis(label='Bollinger b1', scale=sc_co, orientation='vertical') + ax_y2 = Axis(label='Bollinger b2', scale=sc_co2, orientation='vertical', side='right') + new_line = Lines(x=stock.datetime, y=stock['out0'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_line2 = Lines(x=stock.datetime, y=stock['out1'], scales={'x': dt_scale, 'y': sc_co2}, colors=[CATEGORY20[(color_id[0] + 1) % len(CATEGORY20)]]) + new_fig = Figure(marks=[new_line, new_line2], axes=[ax_y, ax_y2]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line, new_line2] + add_new_indicator(new_fig) + return figs + +def update_figure(stock, objects): + line = objects[0] + line2 = objects[1] + with line.hold_trait_notifications() as lc, line2.hold_trait_notifications() as lc2: + line.y = stock['out0'] + line.x = stock.datetime + line2.y = stock['out1'] + line2.x = stock.datetime diff --git a/notebook/cuIndicator/viz/ch_oscillator.py b/notebook/cuIndicator/viz/ch_oscillator.py new file mode 100644 index 00000000..e86180af --- /dev/null +++ b/notebook/cuIndicator/viz/ch_oscillator.py @@ -0,0 +1,39 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import chaikin_oscillator as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntRangeSlider(value=[10, 30], + min=3, + max=60, + step=1, + description="Ch Oscillator:", + disabled=False, + continuous_update=False, + orientation='horizontal', + readout=True) + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + widget = para_selector_widgets[0] + return (stock_df["high"], stock_df["low"], stock_df["close"], stock_df["volume"], widget.value[0], widget.value[1]) + +def process_outputs(output, stock_df): + stock_df['out'] = output + stock_df['out'] = stock_df['out'].fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Ch Osc', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/commodity_channel_index.py b/notebook/cuIndicator/viz/commodity_channel_index.py new file mode 100644 index 00000000..535ee413 --- /dev/null +++ b/notebook/cuIndicator/viz/commodity_channel_index.py @@ -0,0 +1,32 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import commodity_channel_index as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Commodity Channel Index") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + #print ((stock_df["high"],stock_df["low"], stock_df["close"]) + tuple([w.value for w in para_selector_widgets])) + return (stock_df["high"],stock_df["low"], stock_df["close"]) + tuple([w.value for w in para_selector_widgets]) + + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='CCI', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/coppock_curve.py b/notebook/cuIndicator/viz/coppock_curve.py new file mode 100644 index 00000000..5abe2ef1 --- /dev/null +++ b/notebook/cuIndicator/viz/coppock_curve.py @@ -0,0 +1,31 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import coppock_curve as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Coppock Curve") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["close"],) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Coppock Curve', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs + diff --git a/notebook/cuIndicator/viz/donchian_channel.py b/notebook/cuIndicator/viz/donchian_channel.py new file mode 100644 index 00000000..391c94a3 --- /dev/null +++ b/notebook/cuIndicator/viz/donchian_channel.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import donchian_channel as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Donchian Channel") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"], stock_df["low"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Donchian Channel', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/ease_of_movement.py b/notebook/cuIndicator/viz/ease_of_movement.py new file mode 100644 index 00000000..3b4e164a --- /dev/null +++ b/notebook/cuIndicator/viz/ease_of_movement.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import ease_of_movement as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Ease of Movement") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"], stock_df["low"], stock_df["volume"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Ease of Movement', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/ewa.py b/notebook/cuIndicator/viz/ewa.py new file mode 100644 index 00000000..aa1f6147 --- /dev/null +++ b/notebook/cuIndicator/viz/ewa.py @@ -0,0 +1,25 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Lines +import math + +from gquant.cuindicator import exponential_moving_average as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="ewa avg periods") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["close"],) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output, stock_df): + stock_df['out'] = output + stock_df['out'] = stock_df['out'].fillna(math.inf) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc}, colors=[CATEGORY20[color_id[0]]]) + figs = [line] + f.marks = f.marks + figs + return figs diff --git a/notebook/cuIndicator/viz/force_index.py b/notebook/cuIndicator/viz/force_index.py new file mode 100644 index 00000000..4d56cd5d --- /dev/null +++ b/notebook/cuIndicator/viz/force_index.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import force_index as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Force Index") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["close"], stock_df["volume"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Force Index', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/keltner_channel.py b/notebook/cuIndicator/viz/keltner_channel.py new file mode 100644 index 00000000..d1605dfb --- /dev/null +++ b/notebook/cuIndicator/viz/keltner_channel.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import keltner_channel as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Keltner Channel") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"], stock_df["low"], stock_df["close"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Keltner Channel', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/kst_oscillator.py b/notebook/cuIndicator/viz/kst_oscillator.py new file mode 100644 index 00000000..6faaef7a --- /dev/null +++ b/notebook/cuIndicator/viz/kst_oscillator.py @@ -0,0 +1,35 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import kst_oscillator as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="KST Oscillator") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + param = [w.value for w in para_selector_widgets] + print (param) + param_grp = [param[0] + i for i in range(8)] + print (param_grp) + return (stock_df["close"],param_grp[0],param_grp[1],param_grp[2],param_grp[3], + param_grp[4],param_grp[5],param_grp[6],param_grp[7]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='KST Oscillator',scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs diff --git a/notebook/cuIndicator/viz/ma.py b/notebook/cuIndicator/viz/ma.py new file mode 100644 index 00000000..b8050b6e --- /dev/null +++ b/notebook/cuIndicator/viz/ma.py @@ -0,0 +1,26 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Lines +import math + +from gquant.cuindicator import moving_average as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="avg periods") + para_selector_widgets = [para_selector] + + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["close"],) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output, stock_df): + stock_df['out'] = output + stock_df['out'] = stock_df['out'].fillna(math.inf) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc}, colors=[CATEGORY20[color_id[0]]]) + figs = [line] + f.marks = f.marks + figs + return figs diff --git a/notebook/cuIndicator/viz/macd.py b/notebook/cuIndicator/viz/macd.py new file mode 100644 index 00000000..01b2f72a --- /dev/null +++ b/notebook/cuIndicator/viz/macd.py @@ -0,0 +1,49 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import macd as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntRangeSlider(value=[10, 30], + min=3, + max=60, + step=1, + description="MACD:", + disabled=False, + continuous_update=False, + orientation='horizontal', + readout=True) + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + widget = para_selector_widgets[0] + return (stock_df["close"], widget.value[0], widget.value[1]) + +def process_outputs(output, stock_df): + stock_df['out0'] = output.MACD + stock_df['out0'] = stock_df['out0'].fillna(0) + stock_df['out1'] = output.MACDsign + stock_df['out1'] = stock_df['out1'].fillna(0) + stock_df['out2'] = output.MACDdiff + stock_df['out2'] = stock_df['out2'].fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='MACD', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=[stock['out0'], stock['out1'], stock['out2'] ], scales={'x': dt_scale, 'y': sc_co}) # + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs + +def update_figure(stock, objects): + line = objects[0] + with line.hold_trait_notifications(): + line.y = [stock['out0'], stock['out1'], stock['out2']] + line.x = stock.datetime \ No newline at end of file diff --git a/notebook/cuIndicator/viz/mass_index.py b/notebook/cuIndicator/viz/mass_index.py new file mode 100644 index 00000000..4af5aced --- /dev/null +++ b/notebook/cuIndicator/viz/mass_index.py @@ -0,0 +1,39 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import mass_index as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntRangeSlider(value=[10, 30], + min=3, + max=60, + step=1, + description="Mass Index:", + disabled=False, + continuous_update=False, + orientation='horizontal', + readout=True) + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + widget = para_selector_widgets[0] + return (stock_df["high"], stock_df["low"], widget.value[0], widget.value[1]) + +def process_outputs(output, stock_df): + stock_df['out'] = output + stock_df['out'] = stock_df['out'].fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Mass Index', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs diff --git a/notebook/cuIndicator/viz/momentum.py b/notebook/cuIndicator/viz/momentum.py new file mode 100644 index 00000000..99d298ba --- /dev/null +++ b/notebook/cuIndicator/viz/momentum.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import momentum as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Momentum") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["close"],) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Momentum', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs diff --git a/notebook/cuIndicator/viz/money_flow_index.py b/notebook/cuIndicator/viz/money_flow_index.py new file mode 100644 index 00000000..2d794b30 --- /dev/null +++ b/notebook/cuIndicator/viz/money_flow_index.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import money_flow_index as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Money Flow Index") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"],stock_df["low"], stock_df["close"], stock_df["volume"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Money Flow Index', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs diff --git a/notebook/cuIndicator/viz/on_balance_volume.py b/notebook/cuIndicator/viz/on_balance_volume.py new file mode 100644 index 00000000..133f66aa --- /dev/null +++ b/notebook/cuIndicator/viz/on_balance_volume.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import on_balance_volume as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="On Balance volume") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["close"], stock_df["volume"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='On Balance volume', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/parabolic_sar.py b/notebook/cuIndicator/viz/parabolic_sar.py new file mode 100644 index 00000000..6e39ab70 --- /dev/null +++ b/notebook/cuIndicator/viz/parabolic_sar.py @@ -0,0 +1,80 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import ppsr as indicator_fun + +def get_para_widgets(): + #para_selector = widgets.IntSlider(min=2, max=60, description="Parabolic SAR") + para_selector_widgets = [] + return para_selector_widgets + +def get_parameters(stock_df,para_selector_widgets): + return (stock_df["high"], stock_df["low"], stock_df["close"]) + +def process_outputs(output,stock_df): + stock_df['out0'] = output.PP + stock_df['out0'] = stock_df['out0'].fillna(0) + stock_df['out1'] = output.R1 + stock_df['out1'] = stock_df['out1'].fillna(0) + stock_df['out2'] = output.S1 + stock_df['out2'] = stock_df['out2'].fillna(0) + stock_df['out3'] = output.R2 + stock_df['out3'] = stock_df['out3'].fillna(0) + stock_df['out4'] = output.S2 + stock_df['out4'] = stock_df['out4'].fillna(0) + stock_df['out5'] = output.R3 + stock_df['out5'] = stock_df['out5'].fillna(0) + stock_df['out6'] = output.S3 + stock_df['out6'] = stock_df['out6'].fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + sc_co2 = LinearScale() + sc_co3 = LinearScale() + sc_co4 = LinearScale() + sc_co5 = LinearScale() + sc_co6 = LinearScale() + sc_co7 = LinearScale() + + ax_y = Axis(label='PPSR PP', scale=sc_co, orientation='vertical') + ax_y2 = Axis(label='PPSR R1', scale=sc_co2, orientation='vertical', side='right') + ax_y3 = Axis(label='PPSR S1', scale=sc_co3, orientation='vertical', side='right') + ax_y4 = Axis(label='PPSR R2', scale=sc_co4, orientation='vertical', side='right') + ax_y5 = Axis(label='PPSR S2', scale=sc_co5, orientation='vertical', side='right') + ax_y6 = Axis(label='PPSR R3', scale=sc_co6, orientation='vertical', side='right') + ax_y7 = Axis(label='PPSR S3', scale=sc_co7, orientation='vertical', side='right') + new_line = Lines(x=stock.datetime, y=stock['out0'], scales={'x': dt_scale, 'y': sc_co}, + colors=[CATEGORY20[color_id[0]]]) + new_line2 = Lines(x=stock.datetime, y=stock['out1'], scales={'x': dt_scale, 'y': sc_co2}, + colors=[CATEGORY20[(color_id[0] + 1) % len(CATEGORY20)]]) + new_line3 = Lines(x=stock.datetime, y=stock['out2'], scales={'x': dt_scale, 'y': sc_co3}, + colors=[CATEGORY20[(color_id[0] + 2) % len(CATEGORY20)]]) + new_line4 = Lines(x=stock.datetime, y=stock['out3'], scales={'x': dt_scale, 'y': sc_co4}, + colors=[CATEGORY20[(color_id[0] + 3) % len(CATEGORY20)]]) + new_line5 = Lines(x=stock.datetime, y=stock['out4'], scales={'x': dt_scale, 'y': sc_co5}, + colors=[CATEGORY20[(color_id[0] + 4) % len(CATEGORY20)]]) + new_line6 = Lines(x=stock.datetime, y=stock['out5'], scales={'x': dt_scale, 'y': sc_co6}, + colors=[CATEGORY20[(color_id[0] + 5) % len(CATEGORY20)]]) + new_line7 = Lines(x=stock.datetime, y=stock['out6'], scales={'x': dt_scale, 'y': sc_co7}, + colors=[CATEGORY20[(color_id[0] + 6) % len(CATEGORY20)]]) + + + new_fig = Figure(marks=[new_line, new_line2, new_line3, new_line4, + new_line5, new_line6, new_line7], + axes=[ax_y, ax_y2, ax_y3, ax_y4, ax_y5, ax_y6, ax_y7]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line, new_line2, new_line3, new_line4, new_line5, new_line6, new_line7] + add_new_indicator(new_fig) + return figs + +def update_figure(stock, objects): + line = objects[0] + line2 = objects[1] + with line.hold_trait_notifications() as lc, line2.hold_trait_notifications() as lc2: + line.y = stock['out0'] + line.x = stock.datetime + line2.y = stock['out1'] + line2.x = stock.datetime diff --git a/notebook/cuIndicator/viz/rate_of_change.py b/notebook/cuIndicator/viz/rate_of_change.py new file mode 100644 index 00000000..eb076c95 --- /dev/null +++ b/notebook/cuIndicator/viz/rate_of_change.py @@ -0,0 +1,31 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import rate_of_change as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Rate of Change") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["close"],) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + print(stock_df['out']) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Rate of Change', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/rsi.py b/notebook/cuIndicator/viz/rsi.py new file mode 100644 index 00000000..af114156 --- /dev/null +++ b/notebook/cuIndicator/viz/rsi.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import relative_strength_index as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="RSI") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"], stock_df["low"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output, stock_df): + stock_df['out'] = output + stock_df['out'] = stock_df['out'].fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='RSI', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs diff --git a/notebook/cuIndicator/viz/stochastic_oscillator_d.py b/notebook/cuIndicator/viz/stochastic_oscillator_d.py new file mode 100644 index 00000000..b64e2211 --- /dev/null +++ b/notebook/cuIndicator/viz/stochastic_oscillator_d.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import stochastic_oscillator_d as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Stochastic Oscillator D") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"],stock_df["low"], stock_df["close"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Stochastic Oscillator D', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs diff --git a/notebook/cuIndicator/viz/stochastic_oscillator_k.py b/notebook/cuIndicator/viz/stochastic_oscillator_k.py new file mode 100644 index 00000000..25f5f95d --- /dev/null +++ b/notebook/cuIndicator/viz/stochastic_oscillator_k.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import stochastic_oscillator_k as indicator_fun + +def get_para_widgets(): + #para_selector = widgets.IntSlider(min=2, max=60, description="Ultimate Oscillator") + para_selector_widgets = [] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"], stock_df["low"], stock_df["close"]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Stochastic Oscillator K', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/trix.py b/notebook/cuIndicator/viz/trix.py new file mode 100644 index 00000000..7ef40037 --- /dev/null +++ b/notebook/cuIndicator/viz/trix.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import exponential_moving_average as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="TRIX") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["close"],) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output, stock_df): + stock_df['out'] = output + stock_df['out'] = stock_df['out'].fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='TRIX', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/true_strength_index.py b/notebook/cuIndicator/viz/true_strength_index.py new file mode 100644 index 00000000..6ce39a33 --- /dev/null +++ b/notebook/cuIndicator/viz/true_strength_index.py @@ -0,0 +1,39 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import true_strength_index as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntRangeSlider(value=[10, 30], + min=3, + max=60, + step=1, + description="True Strength Index", + disabled=False, + continuous_update=False, + orientation='horizontal', + readout=True) + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + widget = para_selector_widgets[0] + return (stock_df["close"],widget.value[0], widget.value[1]) + +def process_outputs(output, stock_df): + stock_df['out'] = output + stock_df['out'] = stock_df['out'].fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='True Strength Index', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/ultimate_oscillator.py b/notebook/cuIndicator/viz/ultimate_oscillator.py new file mode 100644 index 00000000..4b40252f --- /dev/null +++ b/notebook/cuIndicator/viz/ultimate_oscillator.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import ultimate_oscillator as indicator_fun + +def get_para_widgets(): + #para_selector = widgets.IntSlider(min=2, max=60, description="Ultimate Oscillator") + para_selector_widgets = [] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"], stock_df["low"], stock_df["close"]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Ultimate Oscillator', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/cuIndicator/viz/vortex_indicator.py b/notebook/cuIndicator/viz/vortex_indicator.py new file mode 100644 index 00000000..68d83803 --- /dev/null +++ b/notebook/cuIndicator/viz/vortex_indicator.py @@ -0,0 +1,30 @@ +import ipywidgets as widgets +from bqplot.colorschemes import CATEGORY20 +from bqplot import Axis, Figure, LinearScale, Lines + +from gquant.cuindicator import vortex_indicator as indicator_fun + +def get_para_widgets(): + para_selector = widgets.IntSlider(min=2, max=60, description="Vortex Indicator") + para_selector_widgets = [para_selector] + return para_selector_widgets + +def get_parameters(stock_df, para_selector_widgets): + return (stock_df["high"],stock_df["low"], stock_df["close"]) + tuple([w.value for w in para_selector_widgets]) + +def process_outputs(output,stock_df): + stock_df['out'] = output + stock_df['out'] = output.fillna(0) + return stock_df + +def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): + sc_co = LinearScale() + ax_y = Axis(label='Vortex Indicator', scale=sc_co, orientation='vertical') + new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) + new_fig = Figure(marks=[new_line], axes=[ax_y]) + new_fig.layout.height = indicator_figure_height + new_fig.layout.width = figure_width + figs = [new_line] + # add new figure + add_new_indicator(new_fig) + return figs \ No newline at end of file diff --git a/notebook/mortgage_e2e_gquant/mortgage_common.py b/notebook/mortgage_e2e_gquant/mortgage_common.py new file mode 100644 index 00000000..91ab8467 --- /dev/null +++ b/notebook/mortgage_e2e_gquant/mortgage_common.py @@ -0,0 +1,261 @@ +''' +Collection of functions to run the mortgage example. +''' +import os +from glob import glob + + +class MortgageTaskNames(object): + '''Task names commonly used by scripts for naming tasks when creating + a gQuant mortgage workflow. + ''' + load_acqdata_task_name = 'acqdata' + load_perfdata_task_name = 'perfdata' + ever_feat_task_name = 'ever_features' + delinq_feat_task_name = 'delinq_features' + join_perf_ever_delinq_feat_task_name = 'join_perf_ever_delinq_features' + create_12mon_feat_task_name = 'create_12mon_features' + final_perf_delinq_task_name = 'final_perf_delinq_features' + final_perf_acq_task_name = 'final_perf_acq_df' + + mortgage_workflow_runner_task_name = 'mortgage_workflow_runner' + xgb_trainer_task_name = 'xgb_trainer' + + dask_mortgage_workflow_runner_task_name = 'dask_mortgage_workflow_runner' + dask_xgb_trainer_task_name = 'dask_xgb_trainer' + + +def mortgage_etl_workflow_def( + csvfile_names=None, csvfile_acqdata=None, + csvfile_perfdata=None): + '''Define the ETL (extract-transform-load) portion of the mortgage + workflow. + + :returns: gQuant task-spec list. Currently a simple list of dictionaries. + Each dict is a task-spec per TaskSpecSchema. + :rtype: list + ''' + from gquant.dataframe_flow import TaskSpecSchema + + _basedir = os.path.dirname(__file__) + + mortgage_lib_module = os.path.join(_basedir, 'mortgage_gquant_plugins.py') + + # print('CSVFILE_ACQDATA: ', csvfile_acqdata) + # print('CSVFILE_PERFDATA: ', csvfile_perfdata) + + # load acquisition + load_acqdata_task = { + TaskSpecSchema.task_id: MortgageTaskNames.load_acqdata_task_name, + TaskSpecSchema.node_type: 'CsvMortgageAcquisitionDataLoader', + TaskSpecSchema.conf: { + 'csvfile_names': csvfile_names, + 'csvfile_acqdata': csvfile_acqdata + }, + TaskSpecSchema.inputs: [], + TaskSpecSchema.filepath: mortgage_lib_module + } + + # load performance data + load_perfdata_task = { + TaskSpecSchema.task_id: MortgageTaskNames.load_perfdata_task_name, + TaskSpecSchema.node_type: 'CsvMortgagePerformanceDataLoader', + TaskSpecSchema.conf: { + 'csvfile_perfdata': csvfile_perfdata + }, + TaskSpecSchema.inputs: [], + TaskSpecSchema.filepath: mortgage_lib_module + } + + # calculate loan delinquency stats + ever_feat_task = { + TaskSpecSchema.task_id: MortgageTaskNames.ever_feat_task_name, + TaskSpecSchema.node_type: 'CreateEverFeatures', + TaskSpecSchema.conf: dict(), + TaskSpecSchema.inputs: [MortgageTaskNames.load_perfdata_task_name], + TaskSpecSchema.filepath: mortgage_lib_module + } + + delinq_feat_task = { + TaskSpecSchema.task_id: MortgageTaskNames.delinq_feat_task_name, + TaskSpecSchema.node_type: 'CreateDelinqFeatures', + TaskSpecSchema.conf: dict(), + TaskSpecSchema.inputs: [MortgageTaskNames.load_perfdata_task_name], + TaskSpecSchema.filepath: mortgage_lib_module + } + + join_perf_ever_delinq_feat_task = { + TaskSpecSchema.task_id: + MortgageTaskNames.join_perf_ever_delinq_feat_task_name, + TaskSpecSchema.node_type: 'JoinPerfEverDelinqFeatures', + TaskSpecSchema.conf: dict(), + TaskSpecSchema.inputs: [ + MortgageTaskNames.load_perfdata_task_name, + MortgageTaskNames.ever_feat_task_name, + MortgageTaskNames.delinq_feat_task_name + ], + TaskSpecSchema.filepath: mortgage_lib_module + } + + create_12mon_feat_task = { + TaskSpecSchema.task_id: MortgageTaskNames.create_12mon_feat_task_name, + TaskSpecSchema.node_type: 'Create12MonFeatures', + TaskSpecSchema.conf: dict(), + TaskSpecSchema.inputs: [ + MortgageTaskNames.join_perf_ever_delinq_feat_task_name + ], + TaskSpecSchema.filepath: mortgage_lib_module + } + + final_perf_delinq_task = { + TaskSpecSchema.task_id: MortgageTaskNames.final_perf_delinq_task_name, + TaskSpecSchema.node_type: 'FinalPerfDelinq', + TaskSpecSchema.conf: dict(), + TaskSpecSchema.inputs: [ + MortgageTaskNames.load_perfdata_task_name, + MortgageTaskNames.join_perf_ever_delinq_feat_task_name, + MortgageTaskNames.create_12mon_feat_task_name + ], + TaskSpecSchema.filepath: mortgage_lib_module + } + + final_perf_acq_task = { + TaskSpecSchema.task_id: MortgageTaskNames.final_perf_acq_task_name, + TaskSpecSchema.node_type: 'JoinFinalPerfAcqClean', + TaskSpecSchema.conf: dict(), + TaskSpecSchema.inputs: [ + MortgageTaskNames.final_perf_delinq_task_name, + MortgageTaskNames.load_acqdata_task_name + ], + TaskSpecSchema.filepath: mortgage_lib_module + } + + task_spec_list = [ + load_acqdata_task, load_perfdata_task, + ever_feat_task, delinq_feat_task, join_perf_ever_delinq_feat_task, + create_12mon_feat_task, final_perf_delinq_task, final_perf_acq_task + ] + + return task_spec_list + + +def generate_mortgage_gquant_run_params_list( + mortgage_data_path, start_year, end_year, part_count, + gquant_task_spec_list): + '''For the specified years and limit (part_count) to the number of files + (performance files), generates a list of run_params_dict. + run_params_dict = { + 'replace_spec': replace_spec, + 'task_spec_list': gquant_task_spec_list, + 'out_list': out_list + } + + replace_spec - to be passed to Dataframe flow run command's replace option. + replace_spec = { + MortgageTaskNames.load_acqdata_task_name: { + TaskSpecSchema.conf: { + 'csvfile_names': csvfile_names, + 'csvfile_acqdata': csvfile_acqdata + } + }, + MortgageTaskNames.load_perfdata_task_name: { + TaskSpecSchema.conf: { + 'csvfile_perfdata': csvfile_perfdata + } + } + } + + out_list - Expected to specify one output which should be the final + dataframe produced by the mortgage ETL workflow. + + Example: + from gquant.dataframe_flow import TaskGraph + task_spec_list = run_params_dict['task_spec_list'] + out_list = run_params_dict['out_list'] + replace_spec = run_params_dict['replace_spec'] + task_graph = TaskGraph(task_spec_list) + (final_perf_acq_df,) = task_graph.run(out_list, replace_spec) + + :param str mortgage_data_path: Path to mortgage data. Should have a file + "names.csv" and two subdirectories "acq" and "perf". + + :param int start_year: Start year is used to traverse the appropriate range + of directories with corresponding year(s) in mortgage data. + + :param int end_year: End year is used to traverse the appropriate range + of directories with corresponding year(s) in mortgage data. + + :param int part_count: Limit to how many performance files to load. There + is a single corresponding acquisition file for year and quarter. + Performance files are very large csv files (1GB files) and are broken + down i.e. for a given year and quarter you could have several file + chunks: *.txt_0, *.txt_1, etc. + + :param gquant_task_spec_list: Mortgage ETL workflow list of tasks. Refer to + function mortgage_etl_workflow_def. + + :returns: list of run_params_dict + :rtype: list + + ''' + + from gquant.dataframe_flow import TaskSpecSchema + + csvfile_names = os.path.join(mortgage_data_path, 'names.csv') + acq_data_path = os.path.join(mortgage_data_path, 'acq') + perf_data_path = os.path.join(mortgage_data_path, 'perf') + + quarter = 1 + year = start_year + count = 0 + + out_list = [MortgageTaskNames.final_perf_acq_task_name] + mortgage_run_params_dict_list = [] + while year <= end_year: + if count >= part_count: + break + + perf_data_files = glob(os.path.join( + perf_data_path + "/Performance_{}Q{}*".format( + str(year), str(quarter)))) + + csvfile_acqdata = acq_data_path + "/Acquisition_" + \ + str(year) + "Q" + str(quarter) + ".txt" + + for csvfile_perfdata in perf_data_files: + if count >= part_count: + break + + replace_spec = { + MortgageTaskNames.load_acqdata_task_name: { + TaskSpecSchema.conf: { + 'csvfile_names': csvfile_names, + 'csvfile_acqdata': csvfile_acqdata + } + }, + MortgageTaskNames.load_perfdata_task_name: { + TaskSpecSchema.conf: { + 'csvfile_perfdata': csvfile_perfdata + } + } + } + + # Uncomment 'csvfile_perfdata' for debugging chunks in + # DaskMortgageWorkflowRunner. + run_params_dict = { + # 'csvfile_perfdata': csvfile_perfdata, + 'replace_spec': replace_spec, + 'task_spec_list': gquant_task_spec_list, + 'out_list': out_list + } + + mortgage_run_params_dict_list.append(run_params_dict) + + count += 1 + + quarter += 1 + if quarter == 5: + year += 1 + quarter = 1 + + return mortgage_run_params_dict_list diff --git a/notebook/mortgage_e2e_gquant/mortgage_e2e_gquant.ipynb b/notebook/mortgage_e2e_gquant/mortgage_e2e_gquant.ipynb new file mode 100644 index 00000000..88f58a63 --- /dev/null +++ b/notebook/mortgage_e2e_gquant/mortgage_e2e_gquant.ipynb @@ -0,0 +1,1280 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mortgage Workflow\n", + "\n", + "The original implementation can be found at the [rapidsai notebooks-extendeds](https://github.com/rapidsai/notebooks-extended/blob/462b3b9/intermediate_notebooks/E2E/mortgage/mortgage_e2e.ipynb) site. This notebook is a re-implementation using `gQuant`.\n", + "\n", + "## The Dataset\n", + "The dataset used with this workflow is derived from [Fannie Mae’s Single-Family Loan Performance Data](http://www.fanniemae.com/portal/funding-the-market/data/loan-performance-data.html) with all rights reserved by Fannie Mae. This processed dataset is redistributed with permission and consent from Fannie Mae.\n", + "\n", + "To acquire this dataset, please visit [RAPIDS Datasets Homepage](https://docs.rapids.ai/datasets/mortgage-data)\n", + "\n", + "## Introduction\n", + "The Mortgage workflow is composed of three core phases:\n", + "\n", + "1. ETL - Extract, Transform, Load\n", + "2. Data Conversion\n", + "3. ML - Training\n", + "\n", + "### ETL\n", + "Data is \n", + "1. Read in from storage\n", + "2. Transformed to emphasize key features\n", + "3. Loaded into volatile memory for conversion\n", + "\n", + "### Data Conversion\n", + "Features are\n", + "1. Broken into (labels, data) pairs\n", + "2. Distributed across dask workers if using Dask.\n", + "3. Converted into compressed sparse row (CSR) matrix (DMatrix) format for XGBoost\n", + "\n", + "### Machine Learning\n", + "The CSR data is fed into XGBoost or with a distributed training session with Dask-XGBoost" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1821" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# WARMUP CUDF ENGINE - OPTIONAL\n", + "import gc # python garbage collector\n", + "import cudf\n", + "\n", + "# warmup\n", + "s = cudf.Series([1,2,3,None,4])\n", + "\n", + "del(s)\n", + "gc.collect()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mortgage gQuant Workflow for ETL\n", + "\n", + "Two modules are provided with this notebook and should be in the same location (directory) as this notebook: `mortgage_common.py` and `mortgage_gquant_plugins.py`. The plugins module contains the individuals tasks for loading the mortgage data from csv (command separated) files into `cudf` dataframes and processing/transforming these dataframes for mortgage delinquency analysis. As an example the gQuant task to calculate loan delinquecy status period features is shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "class CreateEverFeatures(Node):\n", + " '''gQuant task/node to calculate delinquecy status period features.\n", + " Refer to columns_setup method for the columns produced.\n", + " '''\n", + " def columns_setup(self):\n", + " self.required = OrderedDict([\n", + " ('loan_id', 'int64'),\n", + " ('current_loan_delinquency_status', 'int32')\n", + " ])\n", + "\n", + " self.retention = {\n", + " 'loan_id': 'int64',\n", + " 'ever_30': 'int8',\n", + " 'ever_90': 'int8',\n", + " 'ever_180': 'int8'\n", + " }\n", + "\n", + " def process(self, inputs):\n", + " '''\n", + " '''\n", + " gdf = inputs[0]\n", + " everdf = gdf[['loan_id', 'current_loan_delinquency_status']]\n", + " everdf = everdf.groupby('loan_id', method='hash', as_index=False).max()\n", + " everdf['ever_30'] = \\\n", + " (everdf['current_loan_delinquency_status'] >= 1).astype('int8')\n", + " everdf['ever_90'] = \\\n", + " (everdf['current_loan_delinquency_status'] >= 3).astype('int8')\n", + " everdf['ever_180'] = \\\n", + " (everdf['current_loan_delinquency_status'] >= 6).astype('int8')\n", + " everdf.drop_column('current_loan_delinquency_status')\n", + "\n", + " return everdf\n", + "\n" + ] + } + ], + "source": [ + "import inspect\n", + "from mortgage_gquant_plugins import CreateEverFeatures\n", + "\n", + "print(inspect.getsource(CreateEverFeatures))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We create a worfklow by defining tasks and specifying their configuration (parameters) and inputs (for basics tutorial on gQuant refer to [01_tutorial.ipynb](https://github.com/rapidsai/gQuant/blob/master/notebook/01_tutorial.ipynb) and custom plugins [05_customize_nodes.ipynb](https://github.com/rapidsai/gQuant/blob/master/notebook/05_customize_nodes.ipynb)). The workflow to calculate the mortgage features and delinquecy is defined in the `mortgage_etl_workflow_def` function in `mortgage_common` module. Its code is shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "def mortgage_etl_workflow_def(\n", + " csvfile_names=None, csvfile_acqdata=None,\n", + " csvfile_perfdata=None):\n", + " '''Define the ETL (extract-transform-load) portion of the mortgage\n", + " workflow.\n", + "\n", + " :returns: gQuant task-spec list. Currently a simple list of dictionaries.\n", + " Each dict is a task-spec per TaskSpecSchema.\n", + " :rtype: list\n", + " '''\n", + " from gquant.dataframe_flow import TaskSpecSchema\n", + "\n", + " _basedir = os.path.dirname(__file__)\n", + "\n", + " mortgage_lib_module = os.path.join(_basedir, 'mortgage_gquant_plugins.py')\n", + "\n", + " # print('CSVFILE_ACQDATA: ', csvfile_acqdata)\n", + " # print('CSVFILE_PERFDATA: ', csvfile_perfdata)\n", + "\n", + " # load acquisition\n", + " load_acqdata_task = {\n", + " TaskSpecSchema.task_id: MortgageTaskNames.load_acqdata_task_name,\n", + " TaskSpecSchema.node_type: 'CsvMortgageAcquisitionDataLoader',\n", + " TaskSpecSchema.conf: {\n", + " 'csvfile_names': csvfile_names,\n", + " 'csvfile_acqdata': csvfile_acqdata\n", + " },\n", + " TaskSpecSchema.inputs: [],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + " }\n", + "\n", + " # load performance data\n", + " load_perfdata_task = {\n", + " TaskSpecSchema.task_id: MortgageTaskNames.load_perfdata_task_name,\n", + " TaskSpecSchema.node_type: 'CsvMortgagePerformanceDataLoader',\n", + " TaskSpecSchema.conf: {\n", + " 'csvfile_perfdata': csvfile_perfdata\n", + " },\n", + " TaskSpecSchema.inputs: [],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + " }\n", + "\n", + " # calculate loan delinquency stats\n", + " ever_feat_task = {\n", + " TaskSpecSchema.task_id: MortgageTaskNames.ever_feat_task_name,\n", + " TaskSpecSchema.node_type: 'CreateEverFeatures',\n", + " TaskSpecSchema.conf: dict(),\n", + " TaskSpecSchema.inputs: [MortgageTaskNames.load_perfdata_task_name],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + " }\n", + "\n", + " delinq_feat_task = {\n", + " TaskSpecSchema.task_id: MortgageTaskNames.delinq_feat_task_name,\n", + " TaskSpecSchema.node_type: 'CreateDelinqFeatures',\n", + " TaskSpecSchema.conf: dict(),\n", + " TaskSpecSchema.inputs: [MortgageTaskNames.load_perfdata_task_name],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + " }\n", + "\n", + " join_perf_ever_delinq_feat_task = {\n", + " TaskSpecSchema.task_id:\n", + " MortgageTaskNames.join_perf_ever_delinq_feat_task_name,\n", + " TaskSpecSchema.node_type: 'JoinPerfEverDelinqFeatures',\n", + " TaskSpecSchema.conf: dict(),\n", + " TaskSpecSchema.inputs: [\n", + " MortgageTaskNames.load_perfdata_task_name,\n", + " MortgageTaskNames.ever_feat_task_name,\n", + " MortgageTaskNames.delinq_feat_task_name\n", + " ],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + " }\n", + "\n", + " create_12mon_feat_task = {\n", + " TaskSpecSchema.task_id: MortgageTaskNames.create_12mon_feat_task_name,\n", + " TaskSpecSchema.node_type: 'Create12MonFeatures',\n", + " TaskSpecSchema.conf: dict(),\n", + " TaskSpecSchema.inputs: [\n", + " MortgageTaskNames.join_perf_ever_delinq_feat_task_name\n", + " ],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + " }\n", + "\n", + " final_perf_delinq_task = {\n", + " TaskSpecSchema.task_id: MortgageTaskNames.final_perf_delinq_task_name,\n", + " TaskSpecSchema.node_type: 'FinalPerfDelinq',\n", + " TaskSpecSchema.conf: dict(),\n", + " TaskSpecSchema.inputs: [\n", + " MortgageTaskNames.load_perfdata_task_name,\n", + " MortgageTaskNames.join_perf_ever_delinq_feat_task_name,\n", + " MortgageTaskNames.create_12mon_feat_task_name\n", + " ],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + " }\n", + "\n", + " final_perf_acq_task = {\n", + " TaskSpecSchema.task_id: MortgageTaskNames.final_perf_acq_task_name,\n", + " TaskSpecSchema.node_type: 'JoinFinalPerfAcqClean',\n", + " TaskSpecSchema.conf: dict(),\n", + " TaskSpecSchema.inputs: [\n", + " MortgageTaskNames.final_perf_delinq_task_name,\n", + " MortgageTaskNames.load_acqdata_task_name\n", + " ],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + " }\n", + "\n", + " task_spec_list = [\n", + " load_acqdata_task, load_perfdata_task,\n", + " ever_feat_task, delinq_feat_task, join_perf_ever_delinq_feat_task,\n", + " create_12mon_feat_task, final_perf_delinq_task, final_perf_acq_task\n", + " ]\n", + "\n", + " return task_spec_list\n", + "\n" + ] + } + ], + "source": [ + "import inspect\n", + "from mortgage_common import mortgage_etl_workflow_def\n", + "\n", + "print(inspect.getsource(mortgage_etl_workflow_def))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize the mortgage ETL workflow." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from gquant.dataframe_flow import TaskGraph\n", + "from nxpd import draw\n", + "\n", + "task_spec_list = mortgage_etl_workflow_def()\n", + "task_graph = TaskGraph(task_spec_list)\n", + "draw(task_graph.viz_graph(), show='ipynb')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's run the workflow and inspect the resultant `final_per_acq_df` dataframe. Adjust your paths below to wherever you downloaded the mortgage dataset to. The `mortgage_data` below is assumed to be in the same directory as this notebook (could be a symlink to wherever the actual data resides), otherwise adjust the paths." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2000Q1.txt_0\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2000Q1.txt\n" + ] + } + ], + "source": [ + "import os\n", + "from gquant.dataframe_flow import TaskGraph\n", + "from mortgage_common import (\n", + " mortgage_etl_workflow_def, MortgageTaskNames)\n", + "\n", + "# mortgage_data_path = '/datasets/rapids_data/mortgage'\n", + "mortgage_data_path = './mortgage_data'\n", + "# _basedir = os.path.abspath('') # path of current notebook\n", + "# mortgage_data_path = os.path.join(_basedir, 'mortgage_data')\n", + "csvfile_names = os.path.join(mortgage_data_path, 'names.csv')\n", + "acq_data_path = os.path.join(mortgage_data_path, 'acq')\n", + "perf_data_path = os.path.join(mortgage_data_path, 'perf')\n", + "\n", + "# Some files out of the mortgage dataset.\n", + "csvfile_acqdata = os.path.join(acq_data_path, 'Acquisition_2000Q1.txt')\n", + "csvfile_perfdata = os.path.join(perf_data_path, 'Performance_2000Q1.txt_0')\n", + "\n", + "gquant_task_spec_list = mortgage_etl_workflow_def(\n", + " csvfile_names, csvfile_acqdata, csvfile_perfdata)\n", + "out_list = [MortgageTaskNames.final_perf_acq_task_name]\n", + "\n", + "task_graph = TaskGraph(gquant_task_spec_list)\n", + "\n", + "(final_perf_acq_df,) = task_graph.run(out_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mortgage Workflow Ouput CUDF Dataframe:\n", + " servicer interest_rate current_actual_upb loan_age remaining_months_to_legal_maturity adj_remaining_months_to_maturity msa ... relocation_mortgage_indicator\n", + "0 -1.0 8.0 74319.0 12.0 348.0 347.0 0.0 ... -1.0\n", + "1 -1.0 8.0 73635.48 24.0 336.0 335.0 0.0 ... -1.0\n", + "2 -1.0 8.0 72795.41 36.0 324.0 322.0 0.0 ... -1.0\n", + "3 -1.0 8.0 -1.0 1.0 359.0 358.0 0.0 ... -1.0\n", + "4 -1.0 8.0 74264.14 13.0 347.0 346.0 0.0 ... -1.0\n", + "5 -1.0 8.0 73576.06 25.0 335.0 334.0 0.0 ... -1.0\n", + "6 -1.0 8.0 72680.39 37.0 323.0 320.0 0.0 ... -1.0\n", + "7 -1.0 8.0 -1.0 2.0 358.0 357.0 0.0 ... -1.0\n", + "8 -1.0 8.0 74208.91 14.0 346.0 345.0 0.0 ... -1.0\n", + "9 -1.0 8.0 73516.25 26.0 334.0 333.0 0.0 ... -1.0\n", + "[9094668 more rows]\n", + "[38 more columns]\n" + ] + } + ], + "source": [ + "print('Mortgage Workflow Ouput CUDF Dataframe:\\n', final_perf_acq_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can indirectly see how much memory is being occupied on the GPU by this cudf dataframe. In my case I see `1863 MB` (assuming only this notebook is running and using the GPU)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pid, process_name, used_gpu_memory [MiB]\n", + "8165, /home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/bin/python, 1863 MiB\n" + ] + } + ], + "source": [ + "!nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can clear this GPU memory by deleting the cudf dataframe and running python garbage collector to force garbage collection. After clearing I see `207 MB` occupied on the GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pid, process_name, used_gpu_memory [MiB]\n", + "8165, /home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/bin/python, 207 MiB\n" + ] + } + ], + "source": [ + "import gc # python garbage collector\n", + "\n", + "del(final_perf_acq_df)\n", + "gc.collect()\n", + "\n", + "!nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mortgage Workflow Runner\n", + "\n", + "The example above loads just one performance and acqusition datafile. The mortgage dataset is broken down into many csv files. The complete worfklow reads these csv files into cudf dataframes, does all the processing on the GPU, then converts to PyArrow table (essentially arrow dataframes), concatenates the arrow tables, and as a final stage converts into one massive pandas dataframe. From this concatenated dataframe the delinquency column is used as labels and the remaining columns are used as training features. The xgboost DMatrix is instantiated from the features and labels and passed to the xgboost booster trainer. The xgboost trainer copies the data to GPU again and trains on GPU.\n", + "\n", + "Below we define the complete data training workflow. This is the non-distributed implementation. The dask distributed implementation will follow. The parameters for the mortgage runner are displayed (limited to 2 files). Below I load 12 files for the actual run. Adjust the `part_count` to something manageable on your system. The limitation will be the host RAM for how many dataframes can be concatenated and the DMatrix instantiated." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameters configuration for Mortgage Workflow Runner (shortened to 2 files)\n", + "[\n", + " {\n", + " \"replace_spec\": {\n", + " \"acqdata\": {\n", + " \"conf\": {\n", + " \"csvfile_names\": \"./mortgage_data/names.csv\",\n", + " \"csvfile_acqdata\": \"./mortgage_data/acq/Acquisition_2000Q1.txt\"\n", + " }\n", + " },\n", + " \"perfdata\": {\n", + " \"conf\": {\n", + " \"csvfile_perfdata\": \"./mortgage_data/perf/Performance_2000Q1.txt_0\"\n", + " }\n", + " }\n", + " },\n", + " \"task_spec_list\": \"This is gquant_task_spec_list\",\n", + " \"out_list\": [\n", + " \"final_perf_acq_df\"\n", + " ]\n", + " },\n", + " {\n", + " \"replace_spec\": {\n", + " \"acqdata\": {\n", + " \"conf\": {\n", + " \"csvfile_names\": \"./mortgage_data/names.csv\",\n", + " \"csvfile_acqdata\": \"./mortgage_data/acq/Acquisition_2000Q2.txt\"\n", + " }\n", + " },\n", + " \"perfdata\": {\n", + " \"conf\": {\n", + " \"csvfile_perfdata\": \"./mortgage_data/perf/Performance_2000Q2.txt_0\"\n", + " }\n", + " }\n", + " },\n", + " \"task_spec_list\": \"This is gquant_task_spec_list\",\n", + " \"out_list\": [\n", + " \"final_perf_acq_df\"\n", + " ]\n", + " }\n", + "]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\n", + "import json\n", + "\n", + "from nxpd import draw\n", + "\n", + "from gquant.dataframe_flow import (TaskSpecSchema, TaskGraph)\n", + "\n", + "from mortgage_common import (\n", + " mortgage_etl_workflow_def, generate_mortgage_gquant_run_params_list,\n", + " MortgageTaskNames)\n", + "\n", + "start_year = 2000\n", + "end_year = 2001 # end_year is inclusive\n", + "# end_year = 2016 # end_year is inclusive\n", + "part_count = 2 # the number of data files to train against\n", + "\n", + "# ADJUST YOUR MORTGAGE DATAPATH IF DIFFERENT\n", + "mortgage_data_path = './mortgage_data'\n", + "\n", + "gquant_task_spec_list = mortgage_etl_workflow_def()\n", + "mortgage_run_params_dict_list = generate_mortgage_gquant_run_params_list(\n", + " mortgage_data_path, start_year, end_year, part_count, gquant_task_spec_list)\n", + "\n", + "mortgage_run_params_dict_list_for_printing = mortgage_run_params_dict_list.copy()\n", + "for iparams_dict in mortgage_run_params_dict_list_for_printing:\n", + " iparams_dict['task_spec_list'] = 'This is gquant_task_spec_list'\n", + "\n", + "print('Parameters configuration for Mortgage Workflow Runner '\n", + " '(shortened to 2 files)')\n", + "print(json.dumps(mortgage_run_params_dict_list_for_printing, indent=2))\n", + "\n", + "# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #\n", + "# ADJUST PART_COUNT FOR YOUR SYSTEM MEMORY\n", + "part_count = 12 # the number of data files to train against\n", + "# part_count = 4 # the number of data files to train against\n", + "\n", + "mortgage_run_params_dict_list = generate_mortgage_gquant_run_params_list(\n", + " mortgage_data_path, start_year, end_year, part_count, gquant_task_spec_list)\n", + "\n", + "_basedir = os.path.abspath('') # path of current notebook\n", + "mortgage_lib_module = os.path.join(_basedir, 'mortgage_gquant_plugins.py')\n", + "\n", + "mortgage_workflow_runner_task = {\n", + " TaskSpecSchema.task_id:\n", + " MortgageTaskNames.mortgage_workflow_runner_task_name,\n", + " TaskSpecSchema.node_type: 'MortgageWorkflowRunner',\n", + " TaskSpecSchema.conf: {\n", + " 'mortgage_run_params_dict_list': mortgage_run_params_dict_list\n", + " },\n", + " TaskSpecSchema.inputs: [],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + "}\n", + "\n", + "# Can be multi-gpu. Set ngpus > 1. This is different than dask xgboost\n", + "# which is distributed multi-gpu i.e. dask-xgboost could distribute on one\n", + "# node or multiple nodes. In distributed mode the dmatrix is distributed.\n", + "ngpus = 1\n", + "xgb_gpu_params = {\n", + " 'nround': 100,\n", + " 'max_depth': 8,\n", + " 'max_leaves': 2 ** 8,\n", + " 'alpha': 0.9,\n", + " 'eta': 0.1,\n", + " 'gamma': 0.1,\n", + " 'learning_rate': 0.1,\n", + " 'subsample': 1,\n", + " 'reg_lambda': 1,\n", + " 'scale_pos_weight': 2,\n", + " 'min_child_weight': 30,\n", + " 'tree_method': 'gpu_hist',\n", + " 'n_gpus': ngpus,\n", + " # 'distributed_dask': True,\n", + " 'loss': 'ls',\n", + " # 'objective': 'gpu:reg:linear',\n", + " 'objective': 'reg:squarederror',\n", + " 'max_features': 'auto',\n", + " 'criterion': 'friedman_mse',\n", + " 'grow_policy': 'lossguide',\n", + " 'verbose': True\n", + "}\n", + "\n", + "xgb_trainer_task = {\n", + " TaskSpecSchema.task_id: MortgageTaskNames.xgb_trainer_task_name,\n", + " TaskSpecSchema.node_type: 'XgbMortgageTrainer',\n", + " TaskSpecSchema.conf: {\n", + " 'delete_dataframes': False,\n", + " 'xgb_gpu_params': xgb_gpu_params\n", + " },\n", + " TaskSpecSchema.inputs: [\n", + " MortgageTaskNames.mortgage_workflow_runner_task_name\n", + " ],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + "}\n", + "\n", + "task_spec_list = [mortgage_workflow_runner_task, xgb_trainer_task]\n", + "task_graph = TaskGraph(task_spec_list)\n", + "draw(task_graph.viz_graph(), show='ipynb')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Refer to `MortgageWorkflowRunner` and `XgbMortgageTrainer` in the `mortgage_gquant_plugins.py` module for the details of the mortage workflow runner and xgboost trainer tasks.\n", + "\n", + "Note the novel manner in which gQuant is used. The `mortgage_workflow_runner` actually runs another gQuant workflow defined by `mortgage_etl_workflow_def()` for each set of acquisition and performance csv files. The output from `mortgage_workflow_runner` is a pandas dataframe (concatenated from processing multiple `final_per_acq_df` dataframes). The `xgb_trainer` is used in an atypical manner. It does not output a dataframe, instead it produces an XGBoost booster. Even though we mostly focus on dataframe flow with gQuant, if the tasks input/output something beside dataframes then gQuant will still run the workflow. When a task does not output a dataframe then gQuant does not perform columns validation. Currently, the responsibility is on the end-user to validate or make sure the input/output types match for the wired non-dataframe tasks. Above only the `xgb_trainer` task's output is not a datframe.\n", + "\n", + "We can run the workflow now and obtain the XGBoost trained booster. You can monitor the GPU utilization in a terminal using `nvidia-smi`. On my node I have 125GB of host RAM and two 16GB GPU cards. I am able to process 12 dataframes. If I load more than 12 dataframes, then the workflow crashes during DMatrix creation due to out of memory error. The DMatrix instantiation seems to inflate the data temporarily and I run out of memory on the host. In a terminal you can watch with nvidia-smi the utilization on the GPU. During XGBoost training I typically observe:\n", + "\n", + "```\n", + "$ nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv\n", + "pid, process_name, used_gpu_memory [MiB]\n", + "27774, /home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/bin/python, 11025 MiB\n", + "\n", + "$ watch -n 0.5 nvidia-smi pmon -c 1\n", + "# gpu pid type sm mem enc dec command\n", + "# Idx # C/G % % % % name\n", + " 0 27774 C 99 28 0 0 python\n", + " 1 - - - - - - -\n", + "\n", + "```\n", + "\n", + "The DMatrix occupies 11GB of GPU memory and XGBoost training is utilizing 99% of compute processing power on the GPU (specifying `ngpus=2` will split the training across two GPUs)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mortgage_workflow_runner:INFO: TRYING TO LOAD 12 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2000Q1.txt_0\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2000Q1.txt\n", + "mortgage_workflow_runner:INFO: LOADED 1 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2000Q2.txt_0\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2000Q2.txt\n", + "mortgage_workflow_runner:INFO: LOADED 2 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2000Q3.txt_0\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2000Q3.txt\n", + "mortgage_workflow_runner:INFO: LOADED 3 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2000Q4.txt_1\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2000Q4.txt\n", + "mortgage_workflow_runner:INFO: LOADED 4 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2000Q4.txt_0\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2000Q4.txt\n", + "mortgage_workflow_runner:INFO: LOADED 5 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2001Q1.txt_1\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2001Q1.txt\n", + "mortgage_workflow_runner:INFO: LOADED 6 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2001Q1.txt_0\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2001Q1.txt\n", + "mortgage_workflow_runner:INFO: LOADED 7 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2001Q2.txt_1_1\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2001Q2.txt\n", + "mortgage_workflow_runner:INFO: LOADED 8 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2001Q2.txt_1_0\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2001Q2.txt\n", + "mortgage_workflow_runner:INFO: LOADED 9 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2001Q2.txt_0_1\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2001Q2.txt\n", + "mortgage_workflow_runner:INFO: LOADED 10 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2001Q2.txt_0_0\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2001Q2.txt\n", + "mortgage_workflow_runner:INFO: LOADED 11 FRAMES\n", + "perfdata:INFO: LOADING: ./mortgage_data/perf/Performance_2001Q3.txt_1_1\n", + "acqdata:INFO: LOADING: ./mortgage_data/acq/Acquisition_2001Q3.txt\n", + "mortgage_workflow_runner:INFO: LOADED 12 FRAMES\n", + "mortgage_workflow_runner:INFO: HOST RAM (MB) TOTAL 128904; USED 17461; FREE 93503\n", + "mortgage_workflow_runner:INFO: RUN PYTHON GARBAGE COLLECTION TO MAYBE CLEAR CPU AND GPU MEMORY\n", + "mortgage_workflow_runner:INFO: HOST RAM (MB) TOTAL 128904; USED 17460; FREE 93504\n", + "mortgage_workflow_runner:INFO: USING ARROW\n", + "mortgage_workflow_runner:INFO: ARROW TO PANDAS\n", + "mortgage_workflow_runner:INFO: HOST RAM (MB) TOTAL 128904; USED 32872; FREE 78092\n", + "xgb_trainer:INFO: JUST BEFORE DMATRIX\n", + "xgb_trainer:INFO: HOST RAM (MB) TOTAL 128904; USED 17559; FREE 93405\n", + "xgb_trainer:INFO: CREATING DMATRIX\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/lib/python3.6/site-packages/xgboost-0.83.dev0-py3.6.egg/xgboost/core.py:604: FutureWarning: Series.base is deprecated and will be removed in a future version\n", + " if getattr(data, 'base', None) is not None and \\\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xgb_trainer:INFO: JUST AFTER DMATRIX\n", + "xgb_trainer:INFO: HOST RAM (MB) TOTAL 128904; USED 63791; FREE 47174\n", + "xgb_trainer:INFO: CLEAR MEMORY JUST BEFORE XGBOOST TRAINING\n", + "xgb_trainer:INFO: HOST RAM (MB) TOTAL 128904; USED 48713; FREE 62252\n", + "xgb_trainer:INFO: RUNNING XGBOOST TRAINING\n", + "XGBOOST BOOSTER:\n", + " \n" + ] + } + ], + "source": [ + "out_list = [\n", + " MortgageTaskNames.mortgage_workflow_runner_task_name,\n", + " MortgageTaskNames.xgb_trainer_task_name\n", + "]\n", + "((mortgage_feat_df_pandas, delinq_df_pandas), bst,) = \\\n", + " task_graph.run(out_list)\n", + "# print(mortgage_feat_df_pandas.head())\n", + "# print(delinq_df_pandas.head())\n", + "\n", + "print('XGBOOST BOOSTER:\\n', bst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specifying ngpus=2 will split the training across two GPUs, but in a non-distributed manner (this approach is being [deprecated](https://xgboost.readthedocs.io/en/latest/gpu/#single-node-multi-gpu) in favor of distributed). If you would like to run with 2 GPUs in this manner, convert the cell below to code (from raw format to code select cell and press Esc+y), and run below on 2 GPUs. If you don't have at least two GPUs do not run the cell below." + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "# CLEAN MEMORY FROM RUN BEFORE\n", + "import gc\n", + "from contextlib import suppress\n", + "\n", + "with suppress(Exception):\n", + " del(bst)\n", + "\n", + "gc.collect()\n", + "\n", + "ngpus = 2\n", + "xgb_gpu_params = {\n", + " 'nround': 100,\n", + " 'max_depth': 8,\n", + " 'max_leaves': 2 ** 8,\n", + " 'alpha': 0.9,\n", + " 'eta': 0.1,\n", + " 'gamma': 0.1,\n", + " 'learning_rate': 0.1,\n", + " 'subsample': 1,\n", + " 'reg_lambda': 1,\n", + " 'scale_pos_weight': 2,\n", + " 'min_child_weight': 30,\n", + " 'tree_method': 'gpu_hist',\n", + " 'n_gpus': ngpus,\n", + " # 'distributed_dask': True,\n", + " 'loss': 'ls',\n", + " # 'objective': 'gpu:reg:linear',\n", + " 'objective': 'reg:squarederror',\n", + " 'max_features': 'auto',\n", + " 'criterion': 'friedman_mse',\n", + " 'grow_policy': 'lossguide',\n", + " 'verbose': True\n", + "}\n", + "\n", + "# By loading existing dataframes no need to re-run\n", + "# mortgage_workflow_runner task.\n", + "replace_spec = {\n", + " MortgageTaskNames.mortgage_workflow_runner_task_name: {\n", + " 'load': [mortgage_feat_df_pandas, delinq_df_pandas]\n", + " },\n", + " MortgageTaskNames.xgb_trainer_task_name: {\n", + " TaskSpecSchema.conf: {\n", + " 'delete_dataframes': False,\n", + " 'xgb_gpu_params': xgb_gpu_params\n", + " }\n", + " }\n", + "}\n", + "\n", + "out_list = [MortgageTaskNames.xgb_trainer_task_name]\n", + "(bst,) = task_graph.run(out_list, replace=replace_spec)\n", + "\n", + "print('XGBOOST BOOSTER:\\n', bst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "During XGBoost training on 2 GPUs above, I typically observe (pid differs from run to run):\n", + "```\n", + "$ nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv\n", + "pid, process_name, used_gpu_memory [MiB]\n", + "12819, /home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/bin/python, 5965 MiB\n", + "12819, /home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/bin/python, 5905 MiB\n", + "\n", + "\n", + "$ watch -n 0.5 nvidia-smi pmon -c 1\n", + "# gpu pid type sm mem enc dec command\n", + "# Idx # C/G % % % % name\n", + " 0 12819 C 98 13 0 0 python\n", + " 1 12819 C 99 13 0 0 python\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " total used free shared buff/cache available\n", + "Mem: 128904 49537 61426 6327 17940 69574\n", + "Swap: 0 0 0\n", + "\n", + "pid, process_name, used_gpu_memory [MiB]\n", + "8165, /home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/bin/python, 11071 MiB\n" + ] + } + ], + "source": [ + "# DISPLAY CURRENT MEMORY ON HOST AND GPU\n", + "!free -m\n", + "!echo\n", + "!nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DASK Distributed Mortgage Workflow Runner\n", + "\n", + "Typically dask with cudf (dask-cudf) or dask with pandas dataframes is used to distribute the dataframe itself. Then operations are performed on the distributed dataframe. The implementation below differs. We will startup GPU dask workers (in my case I have 2 GPUs on the machine) and each worker will run the mortgage workflow to generate a DMatrix. Thus in the end what we will have can be thought of as a distributed DMatrix. It is just two DMatrices one on each worker. This distributed dmatrix is then passed to the dask-xgboost trainer.\n", + "\n", + "#### RECOMMEND TO RESTART THE JUPYTER KERNEL\n", + "\n", + "To release GPU resources from previous non-distributed runs above I recommend you RESTART the Jupyter kernel and continue with the cells below. Otherwise you might run out of memory and/or you might see additional processes consuming GPU.\n", + "\n", + "We start by clearing previous non-distributed run (in case the cells before this one were executed and Jupyter kernel was not restarted), and starting a dask cluster and client." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: NCCL_P2P_DISABLE=1\n", + "\n", + "HOST RAM\n", + " total used free shared buff/cache available\n", + "Mem: 128904 2140 108824 6325 17938 116973\n", + "Swap: 0 0 0\n", + "\n", + "GPU STATUS\n", + "pid, process_name, used_gpu_memory [MiB]\n", + "8165, /home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/bin/python, 239 MiB\n", + "\n", + "\n", + "\n", + "DASK LOCAL CUDA CLUSTER\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

Client

\n", + "\n", + "		\n", + "

Cluster

\n", + "
    \n", + "
  • Workers: 2
    • \n", + "
  • Cores: 8
    • \n", + "
  • Memory: 256.00 GB
    • \n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Disable NCCL P2P. Only necessary for versions of NCCL < 2.4\n", + "# https://rapidsai.github.io/projects/cudf/en/0.8.0/dask-xgb-10min.html#Disable-NCCL-P2P.-Only-necessary-for-versions-of-NCCL-%3C-2.4\n", + "%env NCCL_P2P_DISABLE=1\n", + "\n", + "# CLEAN MEMORY FROM RUN BEFORE\n", + "import gc\n", + "\n", + "from contextlib import suppress\n", + "\n", + "with suppress(Exception):\n", + " del(mortgage_feat_df_pandas)\n", + "\n", + "with suppress(Exception):\n", + " del(delinq_df_pandas)\n", + "\n", + "with suppress(Exception):\n", + " del(bst)\n", + "\n", + "gc.collect()\n", + "\n", + "from dask_cuda import LocalCUDACluster\n", + "from dask.distributed import Client\n", + "\n", + "print('\\nHOST RAM')\n", + "!free -m\n", + "\n", + "print('\\nGPU STATUS')\n", + "# !nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv\n", + "nvsmiquery = !nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv\n", + "# Output will be empty if nothing is happening on GPUs.\n", + "if len(nvsmiquery) == 1:\n", + " print('\\n'.join(nvsmiquery+['No running processes found']))\n", + "else:\n", + " print('\\n'.join(nvsmiquery))\n", + "\n", + "print('\\n\\n')\n", + "# Start cluster and dask client.\n", + "\n", + "memory_limit = 128e9\n", + "threads_per_worker = 4\n", + "cluster = LocalCUDACluster(\n", + " memory_limit=memory_limit,\n", + " threads_per_worker=threads_per_worker)\n", + "client = Client(cluster)\n", + "\n", + "print('DASK LOCAL CUDA CLUSTER')\n", + "client" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we define the gQuant workflow similar to how we did it before in the non-distributed case except we will use tasks `DaskMortgageWorkflowRunner` and `DaskXgbMortgageTrainer` in the `mortgage_gquant_plugins.py` module. Refer to these tasks in the `mortgage_gquant_plugins.py` for code details." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\n", + "from nxpd import draw\n", + "\n", + "from gquant.dataframe_flow import (TaskSpecSchema, TaskGraph)\n", + "\n", + "from mortgage_common import (\n", + " mortgage_etl_workflow_def, generate_mortgage_gquant_run_params_list,\n", + " MortgageTaskNames)\n", + "\n", + "\n", + "# mortgage_data_path = '/datasets/rapids_data/mortgage'\n", + "mortgage_data_path = './mortgage_data'\n", + "\n", + "# Using some default csv files for testing.\n", + "gquant_task_spec_list = mortgage_etl_workflow_def()\n", + "\n", + "start_year = 2000\n", + "end_year = 2001 # end_year is inclusive\n", + "# end_year = 2016 # end_year is inclusive\n", + "\n", + "# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #\n", + "# ADJUST PART_COUNT FOR YOUR SYSTEM MEMORY\n", + "# able to do 18 with create_dmatrix_serially set to True\n", + "# Otherwise need more host RAM. DGX-1 for Analytics has 1TB RAM.\n", + "# part_count = 16 # the number of data files to train against\n", + "# create_dmatrix_serially = False\n", + "part_count = 18 # the number of data files to train against\n", + "create_dmatrix_serially = True\n", + "\n", + "# Use RAPIDS Memory Manager. Seems to work fine without it.\n", + "use_rmm = False\n", + "\n", + "# Clean up intermediate dataframes in the xgboost training task.\n", + "delete_dataframes = True\n", + "\n", + "mortgage_run_params_dict_list = generate_mortgage_gquant_run_params_list(\n", + " mortgage_data_path, start_year, end_year, part_count, gquant_task_spec_list)\n", + "\n", + "_basedir = os.path.abspath('') # path of current notebook\n", + "mortgage_lib_module = os.path.join(_basedir, 'mortgage_gquant_plugins.py')\n", + "\n", + "# filter_dask_logger is primarily for displaying the log in the jupyter\n", + "# notebook. The dask distributed logger is used by gQuant mortgage tasks\n", + "# when running on dask workers.\n", + "filter_dask_logger = True\n", + "\n", + "mortgage_workflow_runner_task = {\n", + " TaskSpecSchema.task_id:\n", + " MortgageTaskNames.dask_mortgage_workflow_runner_task_name,\n", + " TaskSpecSchema.node_type: 'DaskMortgageWorkflowRunner',\n", + " TaskSpecSchema.conf: {\n", + " 'mortgage_run_params_dict_list': mortgage_run_params_dict_list,\n", + " 'client': client,\n", + " 'use_rmm': use_rmm,\n", + " 'filter_dask_logger': filter_dask_logger\n", + " },\n", + " TaskSpecSchema.inputs: [],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + "}\n", + "\n", + "# task_spec_list = [mortgage_workflow_runner_task]\n", + "#\n", + "# out_list = [MortgageTaskNames.dask_mortgage_workflow_runner_task_name]\n", + "# task_graph = TaskGraph(task_spec_list)\n", + "# ((mortgage_feat_df_delinq_df_pandas_futures),) = \\\n", + "# task_graph.run(out_list)\n", + "#\n", + "# print('MORTGAGE_FEAT_DF_DELINQ_DF_PANDAS_FUTURES: ',\n", + "# mortgage_feat_df_delinq_df_pandas_futures)\n", + "\n", + "dxgb_gpu_params = {\n", + " 'nround': 100,\n", + " 'max_depth': 8,\n", + " 'max_leaves': 2 ** 8,\n", + " 'alpha': 0.9,\n", + " 'eta': 0.1,\n", + " 'gamma': 0.1,\n", + " 'learning_rate': 0.1,\n", + " 'subsample': 1,\n", + " 'reg_lambda': 1,\n", + " 'scale_pos_weight': 2,\n", + " 'min_child_weight': 30,\n", + " 'tree_method': 'gpu_hist',\n", + " 'n_gpus': 1,\n", + " 'distributed_dask': True,\n", + " 'loss': 'ls',\n", + " # 'objective': 'gpu:reg:linear',\n", + " 'objective': 'reg:squarederror',\n", + " 'max_features': 'auto',\n", + " 'criterion': 'friedman_mse',\n", + " 'grow_policy': 'lossguide',\n", + " 'verbose': True\n", + "}\n", + "\n", + "dxgb_trainer_task = {\n", + " TaskSpecSchema.task_id: MortgageTaskNames.dask_xgb_trainer_task_name,\n", + " TaskSpecSchema.node_type: 'DaskXgbMortgageTrainer',\n", + " TaskSpecSchema.conf: {\n", + " 'create_dmatrix_serially': create_dmatrix_serially,\n", + " # Able to load 18 files with create_dmatrix_serially set\n", + " # to True. 16 is the max I could do otherwise.\n", + " 'delete_dataframes': delete_dataframes,\n", + " 'dxgb_gpu_params': dxgb_gpu_params,\n", + " 'client': client,\n", + " 'filter_dask_logger': filter_dask_logger\n", + " },\n", + " TaskSpecSchema.inputs: [\n", + " MortgageTaskNames.dask_mortgage_workflow_runner_task_name\n", + " ],\n", + " TaskSpecSchema.filepath: mortgage_lib_module\n", + "}\n", + "\n", + "task_spec_list = [mortgage_workflow_runner_task, dxgb_trainer_task]\n", + "\n", + "task_graph = TaskGraph(task_spec_list)\n", + "draw(task_graph.viz_graph(), show='ipynb')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Final step we run the workflow." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dask_mortgage_workflow_runner:INFO: TRYING TO LOAD 18 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: SPLIT MORTGAGE DATA INTO 2 CHUNKS AMONGST 2 WORKERS\n", + "dask_mortgage_workflow_runner:INFO: 14:37:24.186 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 RUNNING MORTGAGE gQUANT DataframeFlow\n", + "dask_mortgage_workflow_runner:INFO: 14:37:24.187 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 NCCL_P2P_DISABLE: 1\n", + "dask_mortgage_workflow_runner:INFO: 14:37:24.187 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 CUDA_VISIBLE_DEVICES: 1,0\n", + "dask_mortgage_workflow_runner:INFO: 14:37:26.555 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/perf/Performance_2000Q1.txt_0\n", + "dask_mortgage_workflow_runner:INFO: 14:37:33.357 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/acq/Acquisition_2000Q1.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:35.427 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 LOADED 1 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:35.437 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/perf/Performance_2000Q2.txt_0\n", + "dask_mortgage_workflow_runner:INFO: 14:37:39.116 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/acq/Acquisition_2000Q2.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:40.510 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 LOADED 2 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:40.519 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/perf/Performance_2000Q3.txt_0\n", + "dask_mortgage_workflow_runner:INFO: 14:37:44.204 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/acq/Acquisition_2000Q3.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:45.829 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 LOADED 3 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:45.838 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/perf/Performance_2000Q4.txt_1\n", + "dask_mortgage_workflow_runner:INFO: 14:37:46.917 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/acq/Acquisition_2000Q4.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:47.546 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 LOADED 4 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:47.555 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/perf/Performance_2000Q4.txt_0\n", + "dask_mortgage_workflow_runner:INFO: 14:37:51.655 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/acq/Acquisition_2000Q4.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:53.308 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 LOADED 5 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:53.851 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/perf/Performance_2001Q1.txt_1\n", + "dask_mortgage_workflow_runner:INFO: 14:37:57.086 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/acq/Acquisition_2001Q1.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:58.362 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 LOADED 6 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:58.482 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/perf/Performance_2001Q1.txt_0\n", + "dask_mortgage_workflow_runner:INFO: 14:38:02.956 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/acq/Acquisition_2001Q1.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:38:04.534 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 LOADED 7 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:38:04.566 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/perf/Performance_2001Q2.txt_1_1\n", + "dask_mortgage_workflow_runner:INFO: 14:38:07.979 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/acq/Acquisition_2001Q2.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:38:09.330 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 LOADED 8 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:38:09.446 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/perf/Performance_2001Q2.txt_1_0\n", + "dask_mortgage_workflow_runner:INFO: 14:38:13.713 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 1 LOADING: ./mortgage_data/acq/Acquisition_2001Q2.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:38:15.459 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 LOADED 9 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:38:15.502 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 HOST RAM (MB) TOTAL 128904; USED 21174; FREE 89201\n", + "dask_mortgage_workflow_runner:INFO: 14:38:15.503 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 RUN PYTHON GARBAGE COLLECTION TO MAYBE CLEAR CPU AND GPU MEMORY\n", + "dask_mortgage_workflow_runner:INFO: 14:38:15.672 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 HOST RAM (MB) TOTAL 128904; USED 21169; FREE 89194\n", + "dask_mortgage_workflow_runner:INFO: 14:38:15.672 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 USING ARROW\n", + "dask_mortgage_workflow_runner:INFO: 14:38:15.672 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 ARROW TO PANDAS\n", + "dask_mortgage_workflow_runner:INFO: 14:38:17.698 distributed.worker.mortgage_workflow_runner:INFO: WORKER 1 HOST RAM (MB) TOTAL 128904; USED 33039; FREE 77243\n", + "dask_mortgage_workflow_runner:INFO: 14:37:24.186 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 RUNNING MORTGAGE gQUANT DataframeFlow\n", + "dask_mortgage_workflow_runner:INFO: 14:37:24.187 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 NCCL_P2P_DISABLE: 1\n", + "dask_mortgage_workflow_runner:INFO: 14:37:24.187 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 CUDA_VISIBLE_DEVICES: 0,1\n", + "dask_mortgage_workflow_runner:INFO: 14:37:26.550 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/perf/Performance_2001Q2.txt_0_1\n", + "dask_mortgage_workflow_runner:INFO: 14:37:32.901 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/acq/Acquisition_2001Q2.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:34.969 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 LOADED 1 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:34.980 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/perf/Performance_2001Q2.txt_0_0\n", + "dask_mortgage_workflow_runner:INFO: 14:37:39.675 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/acq/Acquisition_2001Q2.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:41.514 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 LOADED 2 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:41.525 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/perf/Performance_2001Q3.txt_1_1\n", + "dask_mortgage_workflow_runner:INFO: 14:37:44.327 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/acq/Acquisition_2001Q3.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:45.528 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 LOADED 3 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:45.538 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/perf/Performance_2001Q3.txt_1_0\n", + "dask_mortgage_workflow_runner:INFO: 14:37:50.258 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/acq/Acquisition_2001Q3.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:37:52.073 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 LOADED 4 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:37:52.083 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/perf/Performance_2001Q3.txt_0_1\n", + "dask_mortgage_workflow_runner:INFO: 14:38:10.848 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/acq/Acquisition_2001Q3.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:38:12.093 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 LOADED 5 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:38:12.388 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/perf/Performance_2001Q3.txt_0_0\n", + "dask_mortgage_workflow_runner:INFO: 14:38:49.168 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/acq/Acquisition_2001Q3.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:38:51.039 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 LOADED 6 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:38:51.122 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/perf/Performance_2001Q4.txt_1_1\n", + "dask_mortgage_workflow_runner:INFO: 14:39:34.755 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/acq/Acquisition_2001Q4.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:39:42.022 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 LOADED 7 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:39:42.076 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/perf/Performance_2001Q4.txt_1_0\n", + "dask_mortgage_workflow_runner:INFO: 14:40:26.012 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/acq/Acquisition_2001Q4.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:40:27.790 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 LOADED 8 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:40:27.933 distributed.worker.csv_mortgage_performance_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/perf/Performance_2001Q4.txt_0_1\n", + "dask_mortgage_workflow_runner:INFO: 14:41:07.497 distributed.worker.csv_mortgage_acquisition_data_loader:INFO: WORKER 0 LOADING: ./mortgage_data/acq/Acquisition_2001Q4.txt\n", + "dask_mortgage_workflow_runner:INFO: 14:41:09.174 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 LOADED 9 FRAMES\n", + "dask_mortgage_workflow_runner:INFO: 14:41:09.228 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 HOST RAM (MB) TOTAL 128904; USED 27832; FREE 78652\n", + "dask_mortgage_workflow_runner:INFO: 14:41:09.228 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 RUN PYTHON GARBAGE COLLECTION TO MAYBE CLEAR CPU AND GPU MEMORY\n", + "dask_mortgage_workflow_runner:INFO: 14:41:09.401 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 HOST RAM (MB) TOTAL 128904; USED 27832; FREE 78652\n", + "dask_mortgage_workflow_runner:INFO: 14:41:09.401 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 USING ARROW\n", + "dask_mortgage_workflow_runner:INFO: 14:41:09.402 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 ARROW TO PANDAS\n", + "dask_mortgage_workflow_runner:INFO: 14:41:10.497 distributed.worker.mortgage_workflow_runner:INFO: WORKER 0 HOST RAM (MB) TOTAL 128904; USED 40387; FREE 66097\n", + "dask_mortgage_workflow_runner:INFO: CLIENT INFO WHO HAS WHAT: {'mortgage_workflow_runner-524827d9eaa91df247185e42269277ca': ('tcp://10.31.229.79:38589',), 'mortgage_workflow_runner-a7b9d85ab42a72e0d3f7488f4b84b6af': ('tcp://10.31.229.79:36823',)}\n", + "dask_xgb_trainer:INFO: CREATING DMATRIX SERIALLY ACROSS 2 WORKERS\n", + "dask_xgb_trainer:INFO: 14:41:10.779 distributed.worker.make_xgb_dmatrix:INFO: CREATING DMATRIX ON WORKER 1\n", + "dask_xgb_trainer:INFO: 14:42:25.666 distributed.worker.make_xgb_dmatrix:INFO: CREATING DMATRIX ON WORKER 0\n", + "dask_xgb_trainer:INFO: JUST AFTER DMATRIX\n", + "dask_xgb_trainer:INFO: HOST RAM (MB) TOTAL 128904; USED 77221; FREE 39151\n", + "dask_xgb_trainer:INFO: RUNNING XGBOOST TRAINING USING DASK-XGBOOST\n", + "XGBOOST BOOSTER:\n", + " \n" + ] + } + ], + "source": [ + "# Look in the terminal where the jupyter was launched from\n", + "# for real-time logging. Otherwise, the logging for individual\n", + "# tasks is captured and displayed after the workers\n", + "# complete that task.\n", + "out_list = [MortgageTaskNames.dask_xgb_trainer_task_name]\n", + "(bst,) = task_graph.run(out_list)\n", + "\n", + "print('XGBOOST BOOSTER:\\n', bst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "During Dask-XGBoost training on 2 GPUs above I observed:\n", + "\n", + "```\n", + "$ nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv\n", + "pid, process_name, used_gpu_memory [MiB]\n", + "15945, /home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/bin/python, 9135 MiB\n", + "15946, /home/avolkov/progs/python_installs/miniconda3/envs/py36-rapids/bin/python, 8681 MiB\n", + "\n", + "$ watch -n 0.5 nvidia-smi pmon -c 1\n", + "# gpu pid type sm mem enc dec command\n", + "# Idx # C/G % % % % name\n", + " 0 15945 C 99 13 0 0 python\n", + " 1 15946 C 99 12 0 0 python\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Summary\n", + "\n", + "We re-implemented the RAPIDS mortgage ETL notebook using gQuant. The benefit of the gQuant implementation is that one can readily break down their workflow into modular parts. It becomes much easier to understand and optimize the individual components of the workflow pipeline.\n", + "\n", + "A non-distributed and a distributed version was demonstrated. The benefits of distributed dask version were that more data was processed (18 files vs 12 files which amounts to 6GB of more data) and the dask-distributed version ran ETL in parallel on two workers (one worker per GPU) thus speeding up ETL. Using distributed version we could scale to multiple nodes as well.\n", + "\n", + "Two scripts are provided along with this notebook `mortgage_run_workflow_local.py` and `mortgage_run_workflow_daskdistrib.py` which run similar code to what was presented in this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# CLEAN UP\n", + "client.close()\n", + "cluster.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "py36-rapids", + "language": "python", + "name": "py36-rapids" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebook/mortgage_e2e_gquant/mortgage_gquant_plugins.py b/notebook/mortgage_e2e_gquant/mortgage_gquant_plugins.py new file mode 100644 index 00000000..b92c682b --- /dev/null +++ b/notebook/mortgage_e2e_gquant/mortgage_gquant_plugins.py @@ -0,0 +1,1368 @@ +''' +''' +import sys +from collections import OrderedDict +import re +import numpy as np +from gquant.dataframe_flow import Node + +import logging + +# logging.config.dictConfig({ +# 'version': 1, +# 'disable_existing_loggers': False +# }) + +_DISTRIB_FORMATTER = None + + +def init_workers_logger(): + '''Initialize logger within all workers. Meant to be run as: + client.run(init_workers_logger) + ''' + global _DISTRIB_FORMATTER + + distrib_logger = logging.getLogger('distributed.worker') + formatter = logging.Formatter( + '%(asctime)s.%(msecs)03d %(name)s:%(levelname)s: %(message)s', + datefmt='%H:%M:%S' + ) + + if _DISTRIB_FORMATTER is None: + _DISTRIB_FORMATTER = distrib_logger.handlers[0].formatter + + distrib_logger.handlers[0].setFormatter(formatter) + + +def restore_workers_logger(): + '''Restore logger within all workers. Meant to be run as: + client.run(restore_workers_logger) + + Run this after printing worker logs i.e. after: + wlogs = client.get_worker_logs() + # print entries form wlogs + + ''' + global _DISTRIB_FORMATTER + + distrib_logger = logging.getLogger('distributed.worker') + if _DISTRIB_FORMATTER is not None: + distrib_logger.handlers[0].setFormatter(_DISTRIB_FORMATTER) + _DISTRIB_FORMATTER = None + + +_CONFIGLOG = True + + +class MortgagePluginsLoggerMgr(object): + '''Logger manager for gQuant mortgage plugins. + + When using this log manager to hijack dask distributed.worker logger + (worker is not None), must first initialize worker loggers via: + client.run(init_workers_logger) + Afer printing out entries from worker logs restore worker loggers via: + client.run(restore_workers_logger) + + WARNING: HIJACKING Dask Distributed logger within dask-workers!!! This + is NOT a great implementation. Done to capture and display logs in Jupyter. + TODO: Implement a server/client logger per example: + https://docs.python.org/3/howto/logging-cookbook.html#sending-and-receiving-logging-events-across-a-network + + + ''' + + def __init__(self, worker=None, logname='mortgage_plugins'): + if worker is None: + logger = self._get_mortgage_plugins_logger() + console_handler = None + else: + # WARNING: HIJACKING Dask Distributed logger!!! + + logger = logging.getLogger('distributed.worker.' + logname) + + console_handler = self._config_log_handler( + logger, propagate=True, addtimestamp=True) + + self._logger = logger + self._console_handler = console_handler + + @staticmethod + def _config_log_handler(logger, propagate=True, addtimestamp=False): + '''Configure logger handler with streaming to stdout and formatter. Add + the handler to the logger. + ''' + + if addtimestamp: + formatter = logging.Formatter( + '%(asctime)s.%(msecs)03d %(name)s:%(levelname)s: %(message)s', + datefmt='%H:%M:%S' + ) + else: + formatter = logging.Formatter( + '%(name)s:%(levelname)s: %(message)s') + + console_handler = logging.StreamHandler(sys.stdout) # console handeler + console_handler.setLevel(logging.INFO) + console_handler.setFormatter(formatter) + + logger.addHandler(console_handler) + logger.setLevel(logging.INFO) + logger.propagate = propagate + + # logger.info('CONFIGURING LOGGER') + + return console_handler + + @classmethod + def _get_mortgage_plugins_logger(cls): + '''Obtain a logger for mortgage plugins. Used when the running process + is not a dask-worker. + ''' + logger = logging.getLogger(__name__) + + global _CONFIGLOG + + if _CONFIGLOG: + cls._config_log_handler(logger, propagate=False) + _CONFIGLOG = False + + # Should only be one handler. With Dask there's a race condition and + # could have multiple logging handlers. + while len(logger.handlers) > 1: + logger.handlers.pop() + + return logger + + def get_logger(self): + '''Get the logger being managed by instante of this log manager.''' + return self._logger + + def cleanup(self): + '''Clean up the logger.''' + if self._console_handler is not None: + self._logger.removeHandler(self._console_handler) + + +first_cap_re = re.compile('(.)([A-Z][a-z]+)') +all_cap_re = re.compile('([a-z0-9])([A-Z])') + + +def convert(name): + '''Convert CamelCase to snake_case. + https://stackoverflow.com/a/1176023/3457624 + ''' + s1 = first_cap_re.sub(r'\1_\2', name) + return all_cap_re.sub(r'\1_\2', s1).lower() + + +class CsvMortgageAcquisitionDataLoader(Node): + '''gQuant task/node to read in a mortgage acquisition CSV file into a cudf + dataframe. Configuration requirements: + 'conf': { + 'csvfile_names': path to mortgage seller names csv datafile + 'csvfile_acqdata': path to mortgage acquisition csv datafile + } + ''' + + cols_dtypes = OrderedDict([ + ('loan_id', 'int64'), + # ('orig_channel', 'category'), + ('orig_channel', 'int32'), + # ('seller_name', 'category'), + ('seller_name', 'int32'), + ('orig_interest_rate', 'float64'), + ('orig_upb', 'int64'), + ('orig_loan_term', 'int64'), + ('orig_date', 'date'), + ('first_pay_date', 'date'), + ('orig_ltv', 'float64'), + ('orig_cltv', 'float64'), + ('num_borrowers', 'float64'), + ('dti', 'float64'), + ('borrower_credit_score', 'float64'), + # ('first_home_buyer', 'category'), + ('first_home_buyer', 'int32'), + # ('loan_purpose', 'category'), + ('loan_purpose', 'int32'), + # ('property_type', 'category'), + ('property_type', 'int32'), + ('num_units', 'int64'), + # ('occupancy_status', 'category'), + ('occupancy_status', 'int32'), + # ('property_state', 'category'), + ('property_state', 'int32'), + ('zip', 'int64'), + ('mortgage_insurance_percent', 'float64'), + # ('product_type', 'category'), + ('product_type', 'int32'), + ('coborrow_credit_score', 'float64'), + ('mortgage_insurance_type', 'float64'), + # ('relocation_mortgage_indicator', 'category') + ('relocation_mortgage_indicator', 'int32') + ]) + + def columns_setup(self): + self.addition = self.cols_dtypes + + def process(self, inputs): + ''' + ''' + import cudf + + worker = None + try: + from dask.distributed import get_worker + worker = get_worker() + except (ValueError, ImportError): + pass + + logname = convert(self.__class__.__name__) + logmgr = MortgagePluginsLoggerMgr(worker, logname) + logger = logmgr.get_logger() + + worker_name = '' + if worker is not None: + worker_name = 'WORKER {} '.format(worker.name) + + col_names_path = self.conf['csvfile_names'] + cols_dtypes = OrderedDict([ + ('seller_name', 'category'), + ('new', 'category'), + ]) + cols = list(cols_dtypes.keys()) + dtypes = list(cols_dtypes.values()) + + names_gdf = cudf.read_csv( + col_names_path, + names=cols, dtype=dtypes, + delimiter='|', skiprows=1) + + acquisition_path = self.conf['csvfile_acqdata'] + cols = list(self.addition.keys()) + dtypes = list(self.addition.values()) + + logger.info(worker_name + 'LOADING: {}'.format(acquisition_path)) + acq_gdf = cudf.read_csv( + acquisition_path, + names=cols, dtype=dtypes, + delimiter='|', skiprows=1) + + acq_gdf = acq_gdf.merge(names_gdf, how='left', on=['seller_name']) + acq_gdf['seller_name'] = acq_gdf['new'] + acq_gdf.drop_column('new') + + logmgr.cleanup() + + return acq_gdf + + +class CsvMortgagePerformanceDataLoader(Node): + '''gQuant task/node to read in a mortgage performance CSV file into a cudf + dataframe. Configuration requirements: + 'conf': { + 'csvfile_perfdata': path to mortgage performance csv datafile + } + ''' + + cols_dtypes = OrderedDict([ + ('loan_id', 'int64'), + ('monthly_reporting_period', 'date'), + # ('servicer', 'category'), + ('servicer', 'int32'), + ('interest_rate', 'float64'), + ('current_actual_upb', 'float64'), + ('loan_age', 'float64'), + ('remaining_months_to_legal_maturity', 'float64'), + ('adj_remaining_months_to_maturity', 'float64'), + ('maturity_date', 'date'), + ('msa', 'float64'), + ('current_loan_delinquency_status', 'int32'), + # ('mod_flag', 'category'), + ('mod_flag', 'int32'), + # ('zero_balance_code', 'category'), + ('zero_balance_code', 'int32'), + ('zero_balance_effective_date', 'date'), + ('last_paid_installment_date', 'date'), + ('foreclosed_after', 'date'), + ('disposition_date', 'date'), + ('foreclosure_costs', 'float64'), + ('prop_preservation_and_repair_costs', 'float64'), + ('asset_recovery_costs', 'float64'), + ('misc_holding_expenses', 'float64'), + ('holding_taxes', 'float64'), + ('net_sale_proceeds', 'float64'), + ('credit_enhancement_proceeds', 'float64'), + ('repurchase_make_whole_proceeds', 'float64'), + ('other_foreclosure_proceeds', 'float64'), + ('non_interest_bearing_upb', 'float64'), + ('principal_forgiveness_upb', 'float64'), + # ('repurchase_make_whole_proceeds_flag', 'category'), + ('repurchase_make_whole_proceeds_flag', 'int32'), + ('foreclosure_principal_write_off_amount', 'float64'), + # ('servicing_activity_indicator', 'category') + ('servicing_activity_indicator', 'int32') + ]) + + def columns_setup(self): + self.addition = self.cols_dtypes + + def process(self, inputs): + ''' + ''' + import cudf + + worker = None + try: + from dask.distributed import get_worker + worker = get_worker() + except (ValueError, ImportError): + pass + + logname = convert(self.__class__.__name__) + logmgr = MortgagePluginsLoggerMgr(worker, logname) + logger = logmgr.get_logger() + + worker_name = '' + if worker is not None: + worker_name = 'WORKER {} '.format(worker.name) + + performance_path = self.conf['csvfile_perfdata'] + logger.info(worker_name + 'LOADING: {}'.format(performance_path)) + + cols = list(self.addition.keys()) + dtypes = list(self.addition.values()) + mortgage_gdf = cudf.read_csv( + performance_path, + names=cols, dtype=dtypes, + delimiter='|', skiprows=1) + + logmgr.cleanup() + + return mortgage_gdf + + +class CreateEverFeatures(Node): + '''gQuant task/node to calculate delinquecy status period features. + Refer to columns_setup method for the columns produced. + ''' + def columns_setup(self): + self.required = OrderedDict([ + ('loan_id', 'int64'), + ('current_loan_delinquency_status', 'int32') + ]) + + self.retention = { + 'loan_id': 'int64', + 'ever_30': 'int8', + 'ever_90': 'int8', + 'ever_180': 'int8' + } + + def process(self, inputs): + ''' + ''' + gdf = inputs[0] + everdf = gdf[['loan_id', 'current_loan_delinquency_status']] + everdf = everdf.groupby('loan_id', method='hash', as_index=False).max() + everdf['ever_30'] = \ + (everdf['current_loan_delinquency_status'] >= 1).astype('int8') + everdf['ever_90'] = \ + (everdf['current_loan_delinquency_status'] >= 3).astype('int8') + everdf['ever_180'] = \ + (everdf['current_loan_delinquency_status'] >= 6).astype('int8') + everdf.drop_column('current_loan_delinquency_status') + + return everdf + + +class CreateDelinqFeatures(Node): + '''gQuant task/node to calculate delinquecy features. + Refer to columns_setup method for the columns produced. + ''' + def columns_setup(self): + self.required = OrderedDict([ + ('loan_id', 'int64'), + ('monthly_reporting_period', 'date'), + ('current_loan_delinquency_status', 'int32') + ]) + + self.retention = { + 'loan_id': 'int64', + 'delinquency_30': 'date', + 'delinquency_90': 'date', + 'delinquency_180': 'date' + } + + def process(self, inputs): + ''' + ''' + perf_df = inputs[0] + delinq_gdf = perf_df[[ + 'loan_id', 'monthly_reporting_period', + 'current_loan_delinquency_status']] + + delinq_30 = delinq_gdf.query('current_loan_delinquency_status >= 1')[[ + 'loan_id', 'monthly_reporting_period']]\ + .groupby('loan_id', method='hash', as_index=False).min() + delinq_30['delinquency_30'] = delinq_30['monthly_reporting_period'] + delinq_30.drop_column('monthly_reporting_period') + + delinq_90 = delinq_gdf.query('current_loan_delinquency_status >= 3')[[ + 'loan_id', 'monthly_reporting_period']]\ + .groupby('loan_id', method='hash', as_index=False).min() + delinq_90['delinquency_90'] = delinq_90['monthly_reporting_period'] + delinq_90.drop_column('monthly_reporting_period') + + delinq_180 = delinq_gdf.query('current_loan_delinquency_status >= 6')[[ + 'loan_id', 'monthly_reporting_period']]\ + .groupby('loan_id', method='hash', as_index=False).min() + delinq_180['delinquency_180'] = delinq_180['monthly_reporting_period'] + delinq_180.drop_column('monthly_reporting_period') + + delinq_merge = delinq_30.merge( + delinq_90, how='left', on=['loan_id'], type='hash') + delinq_merge['delinquency_90'] = delinq_merge['delinquency_90']\ + .fillna(np.dtype('datetime64[ms]').type('1970-01-01') + .astype('datetime64[ms]')) + + delinq_merge = delinq_merge.merge( + delinq_180, how='left', on=['loan_id'], type='hash') + delinq_merge['delinquency_180'] = delinq_merge['delinquency_180']\ + .fillna(np.dtype('datetime64[ms]').type('1970-01-01') + .astype('datetime64[ms]')) + + del(delinq_30) + del(delinq_90) + del(delinq_180) + + return delinq_merge + + +class JoinPerfEverDelinqFeatures(Node): + '''gQuant task/node to merge delinquecy features. Merges dataframes + produced by CreateEverFeatures and CreateDelinqFeatures. + Refer to columns_setup method for the columns produced. + ''' + + cols_dtypes = { + 'timestamp': 'date', + + 'delinquency_12': 'int32', + 'upb_12': 'float64', + + 'ever_30': 'int8', + 'ever_90': 'int8', + 'ever_180': 'int8', + 'delinquency_30': 'date', + 'delinquency_90': 'date', + 'delinquency_180': 'date' + } + + def columns_setup(self): + ''' + ''' + self.retention = { + 'loan_id': 'int64', + + 'timestamp_month': 'int32', + 'timestamp_year': 'int32' + } + self.retention.update(self.cols_dtypes) + + def __join_ever_delinq_features(self, everdf_in, delinqdf_in): + everdf = everdf_in.merge( + delinqdf_in, on=['loan_id'], how='left', type='hash') + everdf['delinquency_30'] = everdf['delinquency_30']\ + .fillna(np.dtype('datetime64[ms]').type('1970-01-01') + .astype('datetime64[ms]')) + everdf['delinquency_90'] = everdf['delinquency_90']\ + .fillna(np.dtype('datetime64[ms]').type('1970-01-01') + .astype('datetime64[ms]')) + everdf['delinquency_180'] = everdf['delinquency_180']\ + .fillna(np.dtype('datetime64[ms]').type('1970-01-01') + .astype('datetime64[ms]')) + + return everdf + + def process(self, inputs): + ''' + ''' + perf_df = inputs[0] + # if using JoinEverDelinqFeatures. Seems unnecessary + # ever_delinq_df = inputs[1] + everdf_in = inputs[1] + delinqdf_in = inputs[2] + + ever_delinq_df = \ + self.__join_ever_delinq_features(everdf_in, delinqdf_in) + + test = perf_df[[ + 'loan_id', + 'monthly_reporting_period', + 'current_loan_delinquency_status', + 'current_actual_upb' + ]] + test['timestamp'] = test['monthly_reporting_period'] + test.drop_column('monthly_reporting_period') + test['timestamp_month'] = test['timestamp'].dt.month + test['timestamp_year'] = test['timestamp'].dt.year + test['delinquency_12'] = test['current_loan_delinquency_status'] + test.drop_column('current_loan_delinquency_status') + test['upb_12'] = test['current_actual_upb'] + test.drop_column('current_actual_upb') + test['upb_12'] = test['upb_12'].fillna(999999999) + test['delinquency_12'] = test['delinquency_12'].fillna(-1) + + joined_df = test.merge( + ever_delinq_df, how='left', on=['loan_id'], type='hash') + + joined_df['ever_30'] = joined_df['ever_30'].fillna(-1) + joined_df['ever_90'] = joined_df['ever_90'].fillna(-1) + joined_df['ever_180'] = joined_df['ever_180'].fillna(-1) + joined_df['delinquency_30'] = joined_df['delinquency_30'].fillna(-1) + joined_df['delinquency_90'] = joined_df['delinquency_90'].fillna(-1) + joined_df['delinquency_180'] = joined_df['delinquency_180'].fillna(-1) + + joined_df['timestamp_month'] = \ + joined_df['timestamp_month'].astype('int32') + joined_df['timestamp_year'] = \ + joined_df['timestamp_year'].astype('int32') + + return joined_df + + +class Create12MonFeatures(Node): + '''gQuant task/node to calculate delinquecy feature over 12 months. + Refer to columns_setup method for the columns produced. + ''' + def columns_setup(self): + ''' + ''' + self.retention = { + 'loan_id': 'int64', + 'delinquency_12': 'int32', + 'upb_12': 'float64', + 'timestamp_month': 'int8', + 'timestamp_year': 'int16' + } + + def process(self, inputs): + ''' + ''' + import cudf + + perf_ever_delinq_df = inputs[0] + + testdfs = [] + n_months = 12 + for y in range(1, n_months + 1): + tmpdf = perf_ever_delinq_df[[ + 'loan_id', 'timestamp_year', 'timestamp_month', + 'delinquency_12', 'upb_12' + ]] + + tmpdf['josh_months'] = \ + tmpdf['timestamp_year'] * 12 + tmpdf['timestamp_month'] + + tmpdf['josh_mody_n'] = \ + ((tmpdf['josh_months'].astype('float64') - 24000 - y) / 12)\ + .floor() + + tmpdf = tmpdf.groupby( + ['loan_id', 'josh_mody_n'], method='hash', as_index=False)\ + .agg({'delinquency_12': 'max', 'upb_12': 'min'}) + + tmpdf['delinquency_12'] = \ + (tmpdf['max_delinquency_12'] > 3).astype('int32') + tmpdf.drop_column('max_delinquency_12') + + tmpdf['delinquency_12'] += \ + (tmpdf['min_upb_12'] == 0).astype('int32') + + tmpdf['upb_12'] = tmpdf['min_upb_12'] + tmpdf.drop_column('min_upb_12') + + tmpdf['timestamp_year'] = \ + (((tmpdf['josh_mody_n'] * n_months) + 24000 + (y - 1)) / 12)\ + .floor().astype('int16') + tmpdf.drop_column('josh_mody_n') + + tmpdf['timestamp_month'] = np.int8(y) + + testdfs.append(tmpdf) + + test_12mon_feat_df = cudf.concat(testdfs) + return test_12mon_feat_df + + +def _null_workaround(df): + '''Fix up null entries in dataframes. This is specific to the mortgage + workflow. + ''' + for column, data_type in df.dtypes.items(): + if str(data_type) == "category": + df[column] = df[column].astype('int32').fillna(-1) + if str(data_type) in \ + ['int8', 'int16', 'int32', 'int64', 'float32', 'float64']: + df[column] = df[column].fillna(np.dtype(data_type).type(-1)) + return df + + +class FinalPerfDelinq(Node): + '''Merge performance dataframe with calculated features dataframes. + Refer to columns_setup method for the columns produced. + ''' + + cols_dtypes = dict() + cols_dtypes.update(CsvMortgagePerformanceDataLoader.cols_dtypes) + cols_dtypes.update(JoinPerfEverDelinqFeatures.cols_dtypes) + + def columns_setup(self): + ''' + ''' + self.retention = self.cols_dtypes + + @staticmethod + def __combine_joined_12_mon(perf_ever_delinq_df, test_12mon_df): + perf_ever_delinq_df.drop_column('delinquency_12') + perf_ever_delinq_df.drop_column('upb_12') + perf_ever_delinq_df['timestamp_year'] = \ + perf_ever_delinq_df['timestamp_year'].astype('int16') + perf_ever_delinq_df['timestamp_month'] = \ + perf_ever_delinq_df['timestamp_month'].astype('int8') + + return perf_ever_delinq_df.merge( + test_12mon_df, + how='left', + on=['loan_id', 'timestamp_year', 'timestamp_month'], + type='hash') + + @classmethod + def __final_performance_delinquency( + cls, perf_df, perf_ever_delinq_df, test_12mon_df): + + joined_df = \ + cls.__combine_joined_12_mon(perf_ever_delinq_df, test_12mon_df) + + merged = _null_workaround(perf_df) + joined_df = _null_workaround(joined_df) + joined_df['timestamp_month'] = \ + joined_df['timestamp_month'].astype('int8') + joined_df['timestamp_year'] = \ + joined_df['timestamp_year'].astype('int16') + merged['timestamp_month'] = merged['monthly_reporting_period'].dt.month + merged['timestamp_month'] = merged['timestamp_month'].astype('int8') + merged['timestamp_year'] = merged['monthly_reporting_period'].dt.year + merged['timestamp_year'] = merged['timestamp_year'].astype('int16') + merged = merged.merge( + joined_df, how='left', + on=['loan_id', 'timestamp_year', 'timestamp_month'], type='hash') + + merged.drop_column('timestamp_month') + merged.drop_column('timestamp_year') + + return merged + + def process(self, inputs): + ''' + ''' + perf_df = inputs[0].copy() + perf_ever_delinq_df = inputs[1].copy() + test_12mon_df = inputs[2] + + final_perf_df = self.__final_performance_delinquency( + perf_df, perf_ever_delinq_df, test_12mon_df) + + return final_perf_df + + +class JoinFinalPerfAcqClean(Node): + '''Merge acquisition dataframe with dataframe produced by FinalPerfDelinq. + Refer to columns_setup method for the columns produced. + ''' + _drop_list = [ + 'loan_id', + 'orig_date', + 'first_pay_date', + 'seller_name', + 'monthly_reporting_period', + 'last_paid_installment_date', + 'maturity_date', + 'ever_30', 'ever_90', 'ever_180', + 'delinquency_30', 'delinquency_90', 'delinquency_180', + 'upb_12', + 'zero_balance_effective_date', + 'foreclosed_after', + 'disposition_date', + 'timestamp' + ] + + cols_dtypes = dict() + cols_dtypes.update(FinalPerfDelinq.cols_dtypes) + cols_dtypes.update(CsvMortgageAcquisitionDataLoader.cols_dtypes) + + # all float64, int32 and int64 types are converted to float32 types. + for icol, itype in cols_dtypes.items(): + if itype in ('float64', 'int32', 'int64',): + cols_dtypes[icol] = 'float32' + + # The only exception is delinquency_12 which remains int32 + cols_dtypes.update({'delinquency_12': 'int32'}) + + for col in _drop_list: + cols_dtypes.pop(col) + + def columns_setup(self): + ''' + ''' + self.retention = self.cols_dtypes + + @classmethod + def __last_mile_cleaning(cls, df): + drop_list = cls._drop_list + for column in drop_list: + df.drop_column(column) + for col, dtype in df.dtypes.iteritems(): + if str(dtype) == 'category': + df[col] = df[col].cat.codes + df[col] = df[col].astype('float32') + df['delinquency_12'] = df['delinquency_12'] > 0 + df['delinquency_12'] = \ + df['delinquency_12'].fillna(False).astype('int32') + for column in df.columns: + df[column] = \ + df[column].fillna(np.dtype(str(df[column].dtype)).type(-1)) + + # return df.to_arrow(preserve_index=False) + return df + + def process(self, inputs): + ''' + ''' + perf_df = inputs[0].copy() + acq_df = inputs[1].copy() + + perf_df = _null_workaround(perf_df) + acq_df = _null_workaround(acq_df) + + perf_acq_df = perf_df.merge( + acq_df, how='left', on=['loan_id'], type='hash') + + perf_acq_df = self.__last_mile_cleaning(perf_acq_df) + + return perf_acq_df + + +def mortgage_gquant_run(run_params_dict): + '''Using dataframe-flow runs the tasks/workflow specified in the + run_params_dict. Expected run_params_dict ex: + run_params_dict = { + 'replace_spec': replace_spec, + 'task_spec_list': gquant_task_spec_list, + 'out_list': out_list + } + + gquant_task_spec_list - Mortgage ETL workflow list of task-specs. Refer to + module mortgage_common function mortgage_etl_workflow_def. + + out_list - Expected to specify one output which should be the final + dataframe produced by the mortgage ETL workflow. + + :param run_params_dict: Dictionary with parameters and gquant task list to + run mortgage workflow. + + ''' + from gquant.dataframe_flow import TaskGraph + + task_spec_list = run_params_dict['task_spec_list'] + out_list = run_params_dict['out_list'] + + replace_spec = run_params_dict['replace_spec'] + task_graph = TaskGraph(task_spec_list) + + (final_perf_acq_df,) = task_graph.run(out_list, replace_spec) + + return final_perf_acq_df + + +def print_ram_usage(worker_name='', logger=None): + '''Display host RAM usage on the system using free -m command.''' + import os + + logmgr = None + if logger is None: + logmgr = MortgagePluginsLoggerMgr() + logger = logmgr.get_logger() + + tot_m, used_m, free_m = \ + map(int, os.popen('free -t -m').readlines()[-1].split()[1:]) + logger.info( + worker_name + 'HOST RAM (MB) TOTAL {}; USED {}; FREE {}' + .format(tot_m, used_m, free_m)) + + if logmgr is not None: + logmgr.cleanup() + + +def mortgage_workflow_runner(mortgage_run_params_dict_list): + '''Runs the mortgage_gquant_run for each entry in the + mortgage_run_params_dict_list. Each entry is a run_params_dict. + Expected run_params_dict: + run_params_dict = { + 'replace_spec': replace_spec, + 'task_spec_list': gquant_task_spec_list, + 'out_list': out_list + } + + :param mortgage_run_params_dict_list: List of run_params_dict + + ''' + import os # @Reimport + import gc + import pyarrow as pa + + # count = len(mortgage_run_params_dict_list) + + # print('LOGGER: ', logger) + + worker = None + try: + from dask.distributed import get_worker + worker = get_worker() + except (ValueError, ImportError): + pass + + logname = 'mortgage_workflow_runner' + logmgr = MortgagePluginsLoggerMgr(worker, logname) + logger = logmgr.get_logger() + + worker_name = '' + if worker is not None: + worker_name = 'WORKER {} '.format(worker.name) + logger.info(worker_name + 'RUNNING MORTGAGE gQUANT DataframeFlow') + logger.info(worker_name + 'NCCL_P2P_DISABLE: {}'.format( + os.environ.get('NCCL_P2P_DISABLE'))) + logger.info(worker_name + 'CUDA_VISIBLE_DEVICES: {}'.format( + os.environ.get('CUDA_VISIBLE_DEVICES'))) + + # cpu_df_concat_pandas = None + final_perf_acq_arrow_concat = None + for ii, run_params_dict in enumerate(mortgage_run_params_dict_list): + # performance_path = run_params_dict['csvfile_perfdata'] + # logger.info(worker_name + 'LOADING: {}'.format(performance_path)) + + final_perf_acq_gdf = mortgage_gquant_run(run_params_dict) + + # CONCATENATE DATAFRAMES AS THEY ARE CALCULATED + + # cpu_df_pandas = gpu_df.to_pandas() + # if cpu_df_concat_pandas is None: + # cpu_df_concat_pandas = cpu_df_pandas + # else: + # cpu_df_concat_pandas = \ + # pd.concat([cpu_df_concat_pandas, cpu_df_pandas]) + # del(cpu_df_pandas) + + final_perf_acq_arrow = \ + final_perf_acq_gdf.to_arrow(preserve_index=False) + if final_perf_acq_arrow_concat is None: + final_perf_acq_arrow_concat = final_perf_acq_arrow + else: + final_perf_acq_arrow_concat = pa.concat_tables([ + final_perf_acq_arrow_concat, final_perf_acq_arrow]) + + del(final_perf_acq_gdf) + logger.info(worker_name + 'LOADED {} FRAMES'.format(ii + 1)) + + print_ram_usage(worker_name, logger) + logger.info(worker_name + 'RUN PYTHON GARBAGE COLLECTION TO MAYBE CLEAR ' + 'CPU AND GPU MEMORY') + + gc.collect() + print_ram_usage(worker_name, logger) + + # df_concat = cpu_df_concat_pandas + # delinq_df = df_concat[['delinquency_12']] + # indexes_besides_delinq = \ + # df_concat.columns.difference(['delinquency_12']) + # mortgage_feat_df = df_concat[list(indexes_besides_delinq)] + # del(df_concat) + + logger.info(worker_name + 'USING ARROW') + + cpu_df_concat_arrow = final_perf_acq_arrow_concat + delinq_arrow_col = cpu_df_concat_arrow.column('delinquency_12') + mortgage_feat_arrow_table = cpu_df_concat_arrow.drop(['delinquency_12']) + + # logger.info(worker_name + 'ARROW TO CUDF') + # delinq_arrow_table = pa.Table.from_arrays([delinq_arrow_col]) + # delinq_df = cudf.DataFrame.from_arrow(delinq_arrow_table) + # mortgage_feat_df = cudf.DataFrame.from_arrow(mortgage_feat_arrow_table) + + logger.info(worker_name + 'ARROW TO PANDAS') + delinq_df = delinq_arrow_col.to_pandas() + mortgage_feat_df = mortgage_feat_arrow_table.to_pandas() + del(delinq_arrow_col) + del(mortgage_feat_arrow_table) + + # clear CPU/GPU memory + gc.collect() + + print_ram_usage(worker_name, logger) + + logmgr.cleanup() + + return (mortgage_feat_df, delinq_df) + + +class MortgageWorkflowRunner(Node): + '''Runs the mortgage gquant workflow and returns the mortgage features + dataframe and mortgage delinquency dataframe. These can be passed on + to xgboost for training. + + conf: { + 'mortgage_run_params_dict_list': REQUIRED. List of dictionaries of + mortgage run params. + } + + mortgage_run_param_dict = { + 'replace_spec': replace_spec, + 'task_spec_list': gquant_task_spec_list, + 'out_list': out_list + } + + Returns: mortgage_feat_df_pandas, delinq_df_pandas + DataframeFlow will return a tuple so unpack as tuple of tuples: + ((mortgage_feat_df_pandas, delinq_df_pandas),) + + ''' + def columns_setup(self): + ''' + ''' + pass + + def process(self, inputs): + logmgr = MortgagePluginsLoggerMgr() + logger = logmgr.get_logger() + + mortgage_run_params_dict_list = \ + self.conf['mortgage_run_params_dict_list'] + + count = len(mortgage_run_params_dict_list) + logger.info('TRYING TO LOAD {} FRAMES'.format(count)) + + mortgage_feat_df_pandas, delinq_df_pandas = \ + mortgage_workflow_runner(mortgage_run_params_dict_list) + + logmgr.cleanup() + + return mortgage_feat_df_pandas, delinq_df_pandas + + +class XgbMortgageTrainer(Node): + '''Trains an XGBoost booster. + + Configuration: + conf: { + 'delete_dataframes': OPTIONAL. Boolean (True or False). Delete the + intermediate mortgage dataframes from which an xgboost dmatrix + is created. This is to potentially clear up CPU/GPU memory. + 'xgb_gpu_params': REQUIRED. Dictionary of xgboost trainer + parameters. + } + + Example of xgb_gpu_params: + xgb_gpu_params = { + 'nround': 100, + 'max_depth': 8, + 'max_leaves': 2 ** 8, + 'alpha': 0.9, + 'eta': 0.1, + 'gamma': 0.1, + 'learning_rate': 0.1, + 'subsample': 1, + 'reg_lambda': 1, + 'scale_pos_weight': 2, + 'min_child_weight': 30, + 'tree_method': 'gpu_hist', + 'n_gpus': 1, + 'loss': 'ls', + # 'objective': 'gpu:reg:linear', + 'objective': 'reg:squarederror', + 'max_features': 'auto', + 'criterion': 'friedman_mse', + 'grow_policy': 'lossguide', + 'verbose': True + } + + Inputs: + mortgage_feat_df_pandas, delinq_df_pandas = inputs[0] + These inputs are provided by MortgageWorkflowRunner. + + Outputs: + bst - XGBoost trained booster model. + + ''' + def columns_setup(self): + ''' + ''' + pass + + def process(self, inputs): + import gc # python standard lib garbage collector + import xgboost as xgb + + logmgr = MortgagePluginsLoggerMgr() + logger = logmgr.get_logger() + + mortgage_feat_df_pandas, delinq_df_pandas = inputs[0] + + delete_dataframes = self.conf.get('delete_dataframes') + xgb_gpu_params = self.conf['xgb_gpu_params'] + + logger.info('JUST BEFORE DMATRIX') + print_ram_usage() + + logger.info('CREATING DMATRIX') + # DMatrix directly from dataframe requires xgboost from rapidsai: + # https://github.com/rapidsai/xgboost + # Convert to DMatrix for XGBoost training. + xgb_dmatrix = xgb.DMatrix(mortgage_feat_df_pandas, delinq_df_pandas) + # logger.info('XGB_DMATRIX:\n', xgb_dmatrix) + + logger.info('JUST AFTER DMATRIX') + print_ram_usage() + + # clear CPU/GPU memory + if delete_dataframes: + del(mortgage_feat_df_pandas) + del(delinq_df_pandas) + + gc.collect() + + logger.info('CLEAR MEMORY JUST BEFORE XGBOOST TRAINING') + print_ram_usage() + + logger.info('RUNNING XGBOOST TRAINING') + + # booster object + bst = xgb.train( + xgb_gpu_params, xgb_dmatrix, + num_boost_round=xgb_gpu_params['nround']) + + logmgr.cleanup() + + return bst + + +# RMM - RAPIDS Memory Manager. +# IMPORTANT!!! IF USING RMM START CLIENT prior to any cudf imports and that +# means prior to any gQuant imports, 3rd party libs with cudf, etc. +# This is needed if distributing workflows to workers. + +def initialize_rmm_pool(): + from librmm_cffi import librmm_config as rmm_cfg + + rmm_cfg.use_pool_allocator = True + # set to 2GiB. Default is 1/2 total GPU memory + # rmm_cfg.initial_pool_size = 2 << 30 + # rmm_cfg.initial_pool_size = 2 << 5 + # rmm_cfg.initial_pool_size = 2 << 33 + import cudf + return cudf.rmm.initialize() + + +def initialize_rmm_no_pool(): + from librmm_cffi import librmm_config as rmm_cfg + + rmm_cfg.use_pool_allocator = False + import cudf + return cudf.rmm.initialize() + + +def finalize_rmm(): + import cudf + return cudf.rmm.finalize() + + +def print_distributed_dask_hijacked_logs(wlogs, logger, filters=None): + '''Prints (uses logger.info) the log entries from worker logs + (wlogs = client.get_worker_logs()). Filters what is printed based on + keywords in the filters. If filters is None then prints everything. + + :param filters: A tuple. Even if one entry ('somestr',) + ''' + # print('WORKER LOGS:\n{}'.format(json.dumps(wlogs, indent=2))) + + for iworker_log in wlogs.values(): + for _, msg in iworker_log: + # if 'distributed.worker.' in msg: + # if filter in msg: + if filters is None: + logger.info(msg) + continue + + if any(ff in msg for ff in filters): + logger.info(msg) + + +class DaskMortgageWorkflowRunner(Node): + '''Runs the mortgage gquant workflow and returns the mortgage features + dataframe and mortgage delinquency dataframe. These can be passed on + to xgboost for training. + + conf: { + 'mortgage_run_params_dict_list': REQUIRED. List of dictionaries of + mortgage run params. + 'client': REQUIRED. Dask distributed client. Runs with distributed + dask. + 'use_rmm': OPTIONAL. Boolean (True or False). Use RAPIDS Memory + Manager., + 'filter_dask_logger': OPTIONAL. Boolean to display hijacked + dask.distributed log. If False (default) then doesn't display. + } + + Format of expected mortgage run params: + mortgage_run_param_dict = { + 'replace_spec': replace_spec, + 'task_spec_list': gquant_task_spec_list, + 'out_list': out_list + } + + Returns: dask-distributed Futures where each future holds a tuple: + mortgage_feat_df_pandas, delinq_df_pandas + The number of futures returned corresponds to the number of workers + obtained from the client. + DataframeFlow will return a tuple so unpack as tuple of tuples in + whatever operates on the future: + ((mortgage_feat_df_pandas, delinq_df_pandas),) + + ''' + def columns_setup(self): + ''' + ''' + pass + + def process(self, inputs): + from dask.distributed import wait + + logmgr = MortgagePluginsLoggerMgr() + logger = logmgr.get_logger() + + filter_dask_logger = self.conf.get('filter_dask_logger') + + client = self.conf['client'] + client.run(init_workers_logger) + + use_rmm = self.conf.get('use_rmm') + if use_rmm: + rmm_init_results = client.run(initialize_rmm_pool) + logger.info('RMM INIT RESULTS:\n', rmm_init_results) + + mortgage_run_params_dict_list = \ + self.conf['mortgage_run_params_dict_list'] + + workers_names = \ + [iw['name'] for iw in client.scheduler_info()['workers'].values()] + nworkers = len(workers_names) + + count = len(mortgage_run_params_dict_list) + logger.info('TRYING TO LOAD {} FRAMES'.format(count)) + + # Make a list of size nworkers where each element is a sublist of + # mortgage_run_params_dict_list. + subset_sz = count // nworkers + mortgage_run_params_dict_list_chunks = [ + mortgage_run_params_dict_list[iw * subset_sz:(iw + 1) * subset_sz] + if iw < (nworkers - 1) else + mortgage_run_params_dict_list[iw * subset_sz:] + for iw in range(nworkers)] + + logger.info( + 'SPLIT MORTGAGE DATA INTO {} CHUNKS AMONGST {} WORKERS' + .format(len(mortgage_run_params_dict_list_chunks), nworkers)) + # For debugging. Add entry 'csvfile_perfdata' to run_params_dict. + # for ii, ichunk in enumerate(mortgage_run_params_dict_list_chunks): + # files_in_chunk = \ + # [iparam['csvfile_perfdata'] for iparam in ichunk] + # logger.info('CHUNK {} FILES TO LOAD: {}'.format( + # ii, files_in_chunk)) + + # List of dask Futures of PyArrow Tables from final_perf_acq cudf + # dataframe + mortgage_feat_df_delinq_df_pandas_futures = client.map( + mortgage_workflow_runner, + mortgage_run_params_dict_list_chunks) + wait(mortgage_feat_df_delinq_df_pandas_futures) + + if filter_dask_logger: + wlogs = client.get_worker_logs() + print_distributed_dask_hijacked_logs( + wlogs, logger, + ('mortgage_workflow_runner', + convert(CsvMortgagePerformanceDataLoader.__name__), + convert(CsvMortgageAcquisitionDataLoader.__name__)) + ) + + client.run(restore_workers_logger) + + cinfo = client.who_has(mortgage_feat_df_delinq_df_pandas_futures) + logger.info('CLIENT INFO WHO HAS WHAT: {}'.format(str(cinfo))) + + if use_rmm: + client.run(finalize_rmm) + client.run(initialize_rmm_no_pool) + + logmgr.cleanup() + + return mortgage_feat_df_delinq_df_pandas_futures + + +class DaskXgbMortgageTrainer(Node): + '''Trains an XGBoost booster using Dask-XGBoost + + Configuration: + conf: { + 'delete_dataframes': OPTIONAL. Boolean (True or False). Delete the + intermediate mortgage dataframes from which an xgboost dmatrix + is created. This is to potentially clear up CPU//GPU memory. + 'dxgb_gpu_params': REQUIRED. Dictionary of dask-xgboost trainer + parameters. + 'client': REQUIRED. Dask distributed client. Runs with distributed + dask. + 'create_dmatrix_serially': OPTIONAL. Boolean (True or False) Might + be able to process more data/dataframes. Creating a dmatrix + takes a lot of host memory. Set delete_dataframes to True as + well to hopefully help with memory. + 'filter_dask_logger': OPTIONAL. Boolean to display hijacked + dask.distributed log. + } + + Example of dxgb_gpu_params: + dxgb_gpu_params = { + 'nround': 100, + 'max_depth': 8, + 'max_leaves': 2 ** 8, + 'alpha': 0.9, + 'eta': 0.1, + 'gamma': 0.1, + 'learning_rate': 0.1, + 'subsample': 1, + 'reg_lambda': 1, + 'scale_pos_weight': 2, + 'min_child_weight': 30, + 'tree_method': 'gpu_hist', + 'n_gpus': 1, + 'distributed_dask': True, + 'loss': 'ls', + # 'objective': 'gpu:reg:linear', + 'objective': 'reg:squarederror', + 'max_features': 'auto', + 'criterion': 'friedman_mse', + 'grow_policy': 'lossguide', + 'verbose': True + } + + Inputs: + mortgage_feat_df_delinq_df_pandas_futures = inputs[0] + These inputs are provided by DaskMortgageWorkflowRunner. + + Outputs: + bst - XGBoost trained booster model. + + ''' + def columns_setup(self): + ''' + ''' + pass + + def process(self, inputs): + import gc # python standard lib garbage collector + import xgboost as xgb + from dask.delayed import delayed + from dask.distributed import (wait, get_worker) + import dask_xgboost as dxgb_gpu + + logmgr = MortgagePluginsLoggerMgr() + logger = logmgr.get_logger() + + filter_dask_logger = self.conf.get('filter_dask_logger') + + client = self.conf['client'] + + client.run(init_workers_logger) + + dxgb_gpu_params = self.conf['dxgb_gpu_params'] + delete_dataframes = self.conf.get('delete_dataframes') + create_dmatrix_serially = self.conf.get('create_dmatrix_serially') + + mortgage_feat_df_delinq_df_pandas_futures = inputs[0] + + def make_xgb_dmatrix( + mortgage_feat_df_delinq_df_pandas_tuple, + delete_dataframes=None): + worker = get_worker() + + logname = 'make_xgb_dmatrix' + logmgr = MortgagePluginsLoggerMgr(worker, logname) + logger = logmgr.get_logger() + + logger.info('CREATING DMATRIX ON WORKER {}'.format(worker.name)) + (mortgage_feat_df, delinq_df) = \ + mortgage_feat_df_delinq_df_pandas_tuple + dmat = xgb.DMatrix(mortgage_feat_df, delinq_df) + + if delete_dataframes: + del(mortgage_feat_df) + del(delinq_df) + # del(mortgage_feat_df_delinq_df_pandas_tuple) + gc.collect() + + logmgr.cleanup() + + return dmat + + dmatrix_delayed_list = [] + nworkers = len(mortgage_feat_df_delinq_df_pandas_futures) + + if create_dmatrix_serially: + logger.info('CREATING DMATRIX SERIALLY ACROSS {} WORKERS' + .format(nworkers)) + else: + logger.info('CREATING DMATRIX IN PARALLEL ACROSS {} WORKERS' + .format(nworkers)) + + for ifut in mortgage_feat_df_delinq_df_pandas_futures: + dmat_delayed = delayed(make_xgb_dmatrix)(ifut, delete_dataframes) + dmat_delayed_persist = dmat_delayed.persist() + + if create_dmatrix_serially: + # TODO: For multinode efficiency need to poll the futures + # such that only doing serial dmatrix creation on the + # same node, but across nodes should be in parallel. + wait(dmat_delayed_persist) + + dmatrix_delayed_list.append(dmat_delayed_persist) + + wait(dmatrix_delayed_list) + + if filter_dask_logger: + wlogs = client.get_worker_logs() + print_distributed_dask_hijacked_logs( + wlogs, logger, ('make_xgb_dmatrix',) + ) + + client.run(restore_workers_logger) + + logger.info('JUST AFTER DMATRIX') + print_ram_usage() + + logger.info('RUNNING XGBOOST TRAINING USING DASK-XGBOOST') + labels = None + bst = dxgb_gpu.train( + client, dxgb_gpu_params, dmatrix_delayed_list, labels, + num_boost_round=dxgb_gpu_params['nround']) + + logmgr.cleanup() + + return bst diff --git a/notebook/mortgage_e2e_gquant/mortgage_run_workflow_daskdistrib.py b/notebook/mortgage_e2e_gquant/mortgage_run_workflow_daskdistrib.py new file mode 100644 index 00000000..07d42336 --- /dev/null +++ b/notebook/mortgage_e2e_gquant/mortgage_run_workflow_daskdistrib.py @@ -0,0 +1,154 @@ +''' +''' +import os + +try: + # Disable NCCL P2P. Only necessary for versions of NCCL < 2.4 + # https://rapidsai.github.io/projects/cudf/en/0.8.0/dask-xgb-10min.html#Disable-NCCL-P2P.-Only-necessary-for-versions-of-NCCL-%3C-2.4 + os.environ["NCCL_P2P_DISABLE"] = "1" +except Exception: + pass + +import json + +from dask_cuda import LocalCUDACluster +from dask.distributed import Client +# from distributed import Client + +from mortgage_common import ( + mortgage_etl_workflow_def, generate_mortgage_gquant_run_params_list, + MortgageTaskNames) + + +def main(): + + memory_limit = 128e9 + threads_per_worker = 4 + cluster = LocalCUDACluster( + memory_limit=memory_limit, + threads_per_worker=threads_per_worker) + client = Client(cluster) + sched_info = client.scheduler_info() + + print('CLIENT: {}'.format(client)) + print('SCHEDULER INFO:\n{}'.format(json.dumps(sched_info, indent=2))) + + # Importing here in case RMM is used later on. Must start client prior + # to importing cudf stuff if using RMM. + from gquant.dataframe_flow import (TaskSpecSchema, TaskGraph) + + # workers_names = \ + # [iw['name'] for iw in client.scheduler_info()['workers'].values()] + # nworkers = len(workers_names) + + _basedir = os.path.dirname(__file__) + # mortgage_data_path = '/datasets/rapids_data/mortgage' + mortgage_data_path = os.path.join(_basedir, 'mortgage_data') + + # Using some default csv files for testing. + # csvfile_names = os.path.join(mortgage_data_path, 'names.csv') + # acq_data_path = os.path.join(mortgage_data_path, 'acq') + # perf_data_path = os.path.join(mortgage_data_path, 'perf') + # csvfile_acqdata = os.path.join(acq_data_path, 'Acquisition_2000Q1.txt') + # csvfile_perfdata = \ + # os.path.join(perf_data_path, 'Performance_2000Q1.txt_0') + # mortgage_etl_workflow_def( + # csvfile_names, csvfile_acqdata, csvfile_perfdata) + + gquant_task_spec_list = mortgage_etl_workflow_def() + + start_year = 2000 + end_year = 2001 # end_year is inclusive + # end_year = 2016 # end_year is inclusive + # part_count = 16 # the number of data files to train against + + # create_dmatrix_serially - When False on same node if not enough host RAM + # then it's a race condition when creating the dmatrix. Make sure enough + # host RAM otherwise set to True. + # create_dmatrix_serially = False + + # able to do 18 with create_dmatrix_serially set to True + part_count = 18 # the number of data files to train against + create_dmatrix_serially = True + # part_count = 4 # the number of data files to train against + + # Use RAPIDS Memory Manager. Seems to work fine without it. + use_rmm = False + + # Clean up intermediate dataframes in the xgboost training task. + delete_dataframes = True + + mortgage_run_params_dict_list = generate_mortgage_gquant_run_params_list( + mortgage_data_path, start_year, end_year, part_count, + gquant_task_spec_list) + + _basedir = os.path.dirname(__file__) + mortgage_lib_module = os.path.join(_basedir, 'mortgage_gquant_plugins.py') + + filter_dask_logger = False + + mortgage_workflow_runner_task = { + TaskSpecSchema.task_id: + MortgageTaskNames.dask_mortgage_workflow_runner_task_name, + TaskSpecSchema.node_type: 'DaskMortgageWorkflowRunner', + TaskSpecSchema.conf: { + 'mortgage_run_params_dict_list': mortgage_run_params_dict_list, + 'client': client, + 'use_rmm': use_rmm, + 'filter_dask_logger': filter_dask_logger, + }, + TaskSpecSchema.inputs: [], + TaskSpecSchema.filepath: mortgage_lib_module + } + + dxgb_gpu_params = { + 'nround': 100, + 'max_depth': 8, + 'max_leaves': 2 ** 8, + 'alpha': 0.9, + 'eta': 0.1, + 'gamma': 0.1, + 'learning_rate': 0.1, + 'subsample': 1, + 'reg_lambda': 1, + 'scale_pos_weight': 2, + 'min_child_weight': 30, + 'tree_method': 'gpu_hist', + 'n_gpus': 1, + 'distributed_dask': True, + 'loss': 'ls', + # 'objective': 'gpu:reg:linear', + 'objective': 'reg:squarederror', + 'max_features': 'auto', + 'criterion': 'friedman_mse', + 'grow_policy': 'lossguide', + 'verbose': True + } + + dxgb_trainer_task = { + TaskSpecSchema.task_id: MortgageTaskNames.dask_xgb_trainer_task_name, + TaskSpecSchema.node_type: 'DaskXgbMortgageTrainer', + TaskSpecSchema.conf: { + 'create_dmatrix_serially': create_dmatrix_serially, + 'delete_dataframes': delete_dataframes, + 'dxgb_gpu_params': dxgb_gpu_params, + 'client': client, + 'filter_dask_logger': filter_dask_logger + }, + TaskSpecSchema.inputs: [ + MortgageTaskNames.dask_mortgage_workflow_runner_task_name + ], + TaskSpecSchema.filepath: mortgage_lib_module + } + + task_spec_list = [mortgage_workflow_runner_task, dxgb_trainer_task] + + out_list = [MortgageTaskNames.dask_xgb_trainer_task_name] + task_graph = TaskGraph(task_spec_list) + (bst,) = task_graph.run(out_list) + + print('XGBOOST BOOSTER:\n', bst) + + +if __name__ == '__main__': + main() diff --git a/notebook/mortgage_e2e_gquant/mortgage_run_workflow_local.py b/notebook/mortgage_e2e_gquant/mortgage_run_workflow_local.py new file mode 100644 index 00000000..bfc61904 --- /dev/null +++ b/notebook/mortgage_e2e_gquant/mortgage_run_workflow_local.py @@ -0,0 +1,110 @@ +''' +''' +import os + +from gquant.dataframe_flow import (TaskSpecSchema, TaskGraph) + + +from mortgage_common import ( + mortgage_etl_workflow_def, generate_mortgage_gquant_run_params_list, + MortgageTaskNames) + + +def main(): + _basedir = os.path.dirname(__file__) + + # mortgage_data_path = '/datasets/rapids_data/mortgage' + mortgage_data_path = os.path.join(_basedir, 'mortgage_data') + + # Using some default csv files for testing. + # csvfile_names = os.path.join(mortgage_data_path, 'names.csv') + # acq_data_path = os.path.join(mortgage_data_path, 'acq') + # perf_data_path = os.path.join(mortgage_data_path, 'perf') + # csvfile_acqdata = os.path.join(acq_data_path, 'Acquisition_2000Q1.txt') + # csvfile_perfdata = \ + # os.path.join(perf_data_path, 'Performance_2000Q1.txt_0') + # mortgage_etl_workflow_def( + # csvfile_names, csvfile_acqdata, csvfile_perfdata) + + gquant_task_spec_list = mortgage_etl_workflow_def() + + start_year = 2000 + end_year = 2001 # end_year is inclusive + # end_year = 2016 # end_year is inclusive + # part_count = 16 # the number of data files to train against + part_count = 12 # the number of data files to train against + # part_count = 4 # the number of data files to train against + + mortgage_run_params_dict_list = generate_mortgage_gquant_run_params_list( + mortgage_data_path, start_year, end_year, part_count, + gquant_task_spec_list) + + _basedir = os.path.dirname(__file__) + mortgage_lib_module = os.path.join(_basedir, 'mortgage_gquant_plugins.py') + + mortgage_workflow_runner_task = { + TaskSpecSchema.task_id: + MortgageTaskNames.mortgage_workflow_runner_task_name, + TaskSpecSchema.node_type: 'MortgageWorkflowRunner', + TaskSpecSchema.conf: { + 'mortgage_run_params_dict_list': mortgage_run_params_dict_list + }, + TaskSpecSchema.inputs: [], + TaskSpecSchema.filepath: mortgage_lib_module + } + + # Can be multi-gpu. Set ngpus > 1. This is different than dask xgboost + # which is distributed multi-gpu i.e. dask-xgboost could distribute on one + # node or multiple nodes. In distributed mode the dmatrix is disributed. + ngpus = 1 + xgb_gpu_params = { + 'nround': 100, + 'max_depth': 8, + 'max_leaves': 2 ** 8, + 'alpha': 0.9, + 'eta': 0.1, + 'gamma': 0.1, + 'learning_rate': 0.1, + 'subsample': 1, + 'reg_lambda': 1, + 'scale_pos_weight': 2, + 'min_child_weight': 30, + 'tree_method': 'gpu_hist', + 'n_gpus': ngpus, + # 'distributed_dask': True, + 'loss': 'ls', + # 'objective': 'gpu:reg:linear', + 'objective': 'reg:squarederror', + 'max_features': 'auto', + 'criterion': 'friedman_mse', + 'grow_policy': 'lossguide', + 'verbose': True + } + + xgb_trainer_task = { + TaskSpecSchema.task_id: MortgageTaskNames.xgb_trainer_task_name, + TaskSpecSchema.node_type: 'XgbMortgageTrainer', + TaskSpecSchema.conf: { + 'delete_dataframes': False, + 'xgb_gpu_params': xgb_gpu_params + }, + TaskSpecSchema.inputs: [ + MortgageTaskNames.mortgage_workflow_runner_task_name + ], + TaskSpecSchema.filepath: mortgage_lib_module + } + + task_spec_list = [mortgage_workflow_runner_task, xgb_trainer_task] + task_graph = TaskGraph(task_spec_list) + + # out_list = [MortgageTaskNames.mortgage_workflow_runner_task_name] + # ((mortgage_feat_df_pandas, delinq_df_pandas),) = task_graph.run(out_list) + + out_list = [MortgageTaskNames.xgb_trainer_task_name] + (bst,) = task_graph.run(out_list) + + print('XGBOOST BOOSTER:\n', bst) + + +if __name__ == '__main__': + main() diff --git a/notebook/plotutils.py b/notebook/plotutils.py new file mode 100644 index 00000000..84721e52 --- /dev/null +++ b/notebook/plotutils.py @@ -0,0 +1,189 @@ +import ipywidgets as widgets + + +def getXGBoostWidget(replace_spec, task_graph, outlist, plot_figures): + + def getRangeSlider(val0, val1, des=""): + return widgets.IntRangeSlider(value=[val0, val1], + min=1, + max=60, + step=1, + description=des, + disabled=False, + continuous_update=False, + orientation='horizontal', + readout=True) + + def getSlider(val, des=""): + return widgets.IntSlider(value=val, + min=1, + max=60, + step=1, + description=des, + disabled=False, + continuous_update=False, + orientation='horizontal', + readout=True, + readout_format='d') + + out = widgets.Output(layout={'border': '1px solid black'}) + + with out: + indicators = \ + replace_spec['node_technical_indicator']['conf']['indicators'] + chaikin_selector = getRangeSlider(indicators[0]['args'][0], + indicators[0]['args'][1], "Chaikin") + + def chaikin_selection(*stocks): + with out: + indicators[0]['args'][0] = chaikin_selector.value[0] + indicators[0]['args'][1] = chaikin_selector.value[1] + chaikin_selector.observe(chaikin_selection, 'value') + + bollinger_selector = getSlider(indicators[1]['args'][0], "bollinger") + + def bollinger_selection(*stocks): + with out: + indicators[1]['args'][0] = bollinger_selector.value + bollinger_selector.observe(bollinger_selection, 'value') + + macd_selector = getRangeSlider(indicators[2]['args'][0], + indicators[2]['args'][1], + "MACD") + + def macd_selection(*stocks): + with out: + indicators[2]['args'][0] = macd_selector.value[0] + indicators[2]['args'][1] = macd_selector.value[1] + macd_selector.observe(macd_selection, 'value') + + rsi_selector = getSlider(indicators[3]['args'][0], "Relative Str") + + def rsi_selection(*stocks): + with out: + indicators[3]['args'][0] = rsi_selector.value + rsi_selector.observe(rsi_selection, 'value') + + atr_selector = getSlider(indicators[4]['args'][0], "ATR") + + def atr_selection(*stocks): + with out: + indicators[4]['args'][0] = atr_selector.value + atr_selector.observe(atr_selection, 'value') + + sod_selector = getSlider(indicators[6]['args'][0], "Sto Osc") + + def sod_selection(*stocks): + with out: + indicators[6]['args'][0] = sod_selector.value + sod_selector.observe(sod_selection, 'value') + + mflow_selector = getSlider(indicators[7]['args'][0], "Money F") + + def mflow_selection(*stocks): + with out: + indicators[7]['args'][0] = mflow_selector.value + mflow_selector.observe(mflow_selection, 'value') + + findex_selector = getSlider(indicators[8]['args'][0], "Force Index") + + def findex_selection(*stocks): + with out: + indicators[8]['args'][0] = findex_selector.value + findex_selector.observe(findex_selection, 'value') + + adis_selector = getSlider(indicators[10]['args'][0], "Ave DMI") + + def adis_selection(*stocks): + with out: + indicators[10]['args'][0] = adis_selector.value + adis_selector.observe(adis_selection, 'value') + + ccindex_selector = getSlider(indicators[11]['args'][0], "Comm Cha") + + def ccindex_selection(*stocks): + with out: + indicators[11]['args'][0] = ccindex_selector.value + ccindex_selector.observe(ccindex_selection, 'value') + + bvol_selector = getSlider(indicators[12]['args'][0], "On Balance") + + def bvol_selection(*stocks): + with out: + indicators[12]['args'][0] = bvol_selector.value + bvol_selector.observe(bvol_selection, 'value') + + vindex_selector = getSlider(indicators[13]['args'][0], "Vortex") + + def vindex_selection(*stocks): + with out: + indicators[13]['args'][0] = vindex_selector.value + vindex_selector.observe(vindex_selection, 'value') + + mindex_selector = getRangeSlider(indicators[15]['args'][0], + indicators[15]['args'][1], + "Mass Index") + + def mindex_selection(*stocks): + with out: + indicators[15]['args'][0] = mindex_selector.value[0] + indicators[15]['args'][1] = mindex_selector.value[1] + mindex_selector.observe(mindex_selection, 'value') + + tindex_selector = getRangeSlider(indicators[16]['args'][0], + indicators[16]['args'][1], + "True Strength") + + def tindex_selection(*stocks): + with out: + indicators[16]['args'][0] = tindex_selector.value[0] + indicators[16]['args'][1] = tindex_selector.value[1] + tindex_selector.observe(tindex_selection, 'value') + + emove_selector = getSlider(indicators[17]['args'][0], "Easy Move") + + def emove_selection(*stocks): + with out: + indicators[17]['args'][0] = emove_selector.value + emove_selector.observe(emove_selection, 'value') + + cc_selector = getSlider(indicators[18]['args'][0], "Cppock Curve") + + def cc_selection(*stocks): + with out: + indicators[18]['args'][0] = cc_selector.value + cc_selector.observe(cc_selection, 'value') + + kchannel_selector = getSlider(indicators[19]['args'][0], + "Keltner Channel") + + def kchannel_selection(*stocks): + with out: + indicators[19]['args'][0] = kchannel_selector.value + kchannel_selector.observe(kchannel_selection, 'value') + + button = widgets.Button( + description='Compute', + disabled=False, + button_style='', + tooltip='Click me') + + def on_button_clicked(b): + with out: + print("Button clicked.") + w.children = (w.children[0], widgets.Label("Busy...."),) + o_gpu = task_graph.run(outputs=outlist, + replace=replace_spec) + figure_combo = plot_figures(o_gpu) + w.children = (w.children[0], figure_combo,) + button.on_click(on_button_clicked) + + selectors = widgets.VBox([chaikin_selector, bollinger_selector, + macd_selector, rsi_selector, atr_selector, + sod_selector, mflow_selector, findex_selector, + adis_selector, ccindex_selector, bvol_selector, + vindex_selector, mindex_selector, + tindex_selector, emove_selector, cc_selector, + kchannel_selector, button]) + w = widgets.VBox([selectors]) + return w diff --git a/task_example/port_trade.yaml b/task_example/port_trade.yaml index c6f03e86..b27a81e5 100644 --- a/task_example/port_trade.yaml +++ b/task_example/port_trade.yaml @@ -1,87 +1,87 @@ -- id: node_csvdata +- id: load_csv_data type: CsvStockLoader conf: path: ./data/stock_price_hist.csv.gz inputs: [] -- id: node_sort +- id: sort type: SortNode conf: keys: - asset - datetime inputs: - - node_csvdata -- id: node_addReturn + - load_csv_data +- id: add_return type: ReturnFeatureNode conf: {} inputs: - - node_sort -- id: node_addIndicator + - sort +- id: add_indicator type: AssetIndicatorNode conf: {} inputs: - - node_addReturn -- id: node_volumeMean + - add_return +- id: volume_mean type: AverageNode conf: column: volume inputs: - - node_addIndicator -- id: node_renameMeanVolume + - add_indicator +- id: rename_mean_volume type: RenameNode conf: old: volume new: volume_mean inputs: - - node_volumeMean -- id: node_leftMergeMeanVolume + - volume_mean +- id: left_merge_mean_volume type: LeftMergeNode conf: column: asset inputs: - - node_addIndicator - - node_renameMeanVolume -- id: node_maxReturns + - add_indicator + - rename_mean_volume +- id: max_returns type: MaxNode conf: column: returns inputs: - - node_addIndicator -- id: node_renameMaxReturn + - add_indicator +- id: rename_max_return type: RenameNode conf: old: returns new: returns_max inputs: - - node_maxReturns -- id: node_leftMergeMaxReturn + - max_returns +- id: left_merge_max_return type: LeftMergeNode conf: column: asset inputs: - - node_leftMergeMeanVolume - - node_renameMaxReturn -- id: node_minReturns + - left_merge_mean_volume + - rename_max_return +- id: min_returns type: MinNode conf: column: returns inputs: - - node_addIndicator -- id: node_renameMinReturn + - add_indicator +- id: rename_min_return type: RenameNode conf: old: returns new: returns_min inputs: - - node_minReturns -- id: node_leftMergeMinReturn + - min_returns +- id: left_merge_min_return type: LeftMergeNode conf: column: asset inputs: - - node_leftMergeMaxReturn - - node_renameMinReturn -- id: node_filterValue + - left_merge_max_return + - rename_min_return +- id: filter_value type: ValueFilterNode conf: - column: volume_mean @@ -91,8 +91,8 @@ - column: returns_min min: -10.0 inputs: - - node_leftMergeMinReturn -- id: node_dropColumns + - left_merge_min_return +- id: drop_columns type: DropNode conf: columns: @@ -104,40 +104,39 @@ - low - volume inputs: - - node_filterValue -- id: node_sort2 + - filter_value +- id: sort_2 type: SortNode conf: keys: - asset - datetime inputs: - - node_dropColumns -- id: node_exp_strategy + - drop_columns +- id: exp_strategy type: PortExpMovingAverageStrategyNode conf: fast: 5 slow: 20 inputs: - - node_sort2 -- id: node_backtest + - sort_2 +- id: backtest type: SimpleBackTestNode conf: {} inputs: - - node_exp_strategy -- id: node_portfolioOpt + - exp_strategy +- id: portfolio_opt type: SimpleAveragePortOpt conf: {} inputs: - - node_backtest -- id: node_sharpeRatio + - backtest +- id: sharpe_ratio type: SharpeRatioNode conf: {} inputs: - - node_portfolioOpt -- id: node_cumlativeReturn + - portfolio_opt +- id: cumlative_return type: CumReturnNode conf: {'points': 300} inputs: - - node_portfolioOpt - + - portfolio_opt \ No newline at end of file diff --git a/task_example/xgboost_trade.yaml b/task_example/xgboost_trade.yaml new file mode 100644 index 00000000..f55c084b --- /dev/null +++ b/task_example/xgboost_trade.yaml @@ -0,0 +1,206 @@ +- id: node_csvdata + type: CsvStockLoader + conf: + path: ./data/stock_price_hist.csv.gz + inputs: [] +- id: node_sort + type: SortNode + conf: + keys: + - asset + - datetime + inputs: + - node_csvdata +- id: node_addReturn + type: ReturnFeatureNode + conf: {} + inputs: + - node_sort +- id: node_addIndicator + type: AssetIndicatorNode + conf: {} + inputs: + - node_addReturn +- id: node_volumeMean + type: AverageNode + conf: + column: volume + inputs: + - node_addIndicator +- id: node_renameMeanVolume + type: RenameNode + conf: + old: volume + new: volume_mean + inputs: + - node_volumeMean +- id: node_leftMergeMeanVolume + type: LeftMergeNode + conf: + column: asset + inputs: + - node_addIndicator + - node_renameMeanVolume +- id: node_maxReturns + type: MaxNode + conf: + column: returns + inputs: + - node_addIndicator +- id: node_renameMaxReturn + type: RenameNode + conf: + old: returns + new: returns_max + inputs: + - node_maxReturns +- id: node_leftMergeMaxReturn + type: LeftMergeNode + conf: + column: asset + inputs: + - node_leftMergeMeanVolume + - node_renameMaxReturn +- id: node_minReturns + type: MinNode + conf: + column: returns + inputs: + - node_addIndicator +- id: node_renameMinReturn + type: RenameNode + conf: + old: returns + new: returns_min + inputs: + - node_minReturns +- id: node_leftMergeMinReturn + type: LeftMergeNode + conf: + column: asset + inputs: + - node_leftMergeMaxReturn + - node_renameMinReturn +- id: node_filterValue + type: ValueFilterNode + conf: + - column: volume_mean + min: 10.0 + - column: returns_max + max: 10.0 + - column: returns_min + min: -10.0 + inputs: + - node_leftMergeMinReturn +- id: node_dropColumns + type: DropNode + conf: + columns: + - volume_mean + - returns_min + - returns_max + inputs: + - node_filterValue +- id: node_sort2 + type: SortNode + conf: + keys: + - asset + - datetime + inputs: + - node_dropColumns +- id: node_technical_indicator + type: IndicatorNode + conf: + indicators: + - function: port_chaikin_oscillator + columns: + - high + - low + - close + - volume + args: + - 10 + - 20 + - function: port_bollinger_bands + columns: + - close + args: + - 10 + outputs: + - b1 + - b2 + - function: port_shift + columns: + - returns + args: + - -1 + remove_na: true + inputs: + - node_sort2 +- id: node_xgboost_strategy + type: XGBoostStrategyNode + conf: + train_date: 2010-1-1 + target: SHIFT_-1 + no_feature: + asset: int64 + datetime: datetime64[ms] + volume: float64 + close: float64 + open: float64 + high: float64 + low: float64 + returns: float64 + indicator: int32 + inputs: + - node_technical_indicator +- id: node_backtest + type: SimpleBackTestNode + conf: {} + inputs: + - node_xgboost_strategy +- id: node_training_df + type: DatetimeFilterNode + conf: + beg: 1900-1-1 + end: 2010-1-1 + inputs: + - node_backtest +- id: node_portOpt2 + type: SimpleAveragePortOpt + conf: {} + inputs: + - node_training_df +- id: node_sharpe_training + type: SharpeRatioNode + conf: {} + inputs: + - node_portOpt2 +- id: node_testing_df + type: DatetimeFilterNode + conf: + beg: 2010-1-1 + end: 2020-1-1 + inputs: + - node_backtest +- id: node_portOpt1 + type: SimpleAveragePortOpt + conf: {} + inputs: + - node_testing_df +- id: node_sharpe_testing + type: SharpeRatioNode + conf: {} + inputs: + - node_portOpt1 +- id: node_cumlativeReturn_testing + type: CumReturnNode + conf: {'points': 300} + inputs: + - node_portOpt1 +- id: node_cumlativeReturn_training + type: CumReturnNode + conf: {'points': 300} + inputs: + - node_portOpt2 diff --git a/tests/unit/test_indicator_node.py b/tests/unit/test_indicator_node.py new file mode 100644 index 00000000..42f29657 --- /dev/null +++ b/tests/unit/test_indicator_node.py @@ -0,0 +1,207 @@ +''' +Technical Indicator Node Unit Tests + +To run unittests: + +# Using standard library unittest + +python -m unittest -v +python -m unittest tests/unit/test_indicator_node.py -v + +or + +python -m unittest discover +python -m unittest discover -s -p 'test_*.py' + +# Using pytest +# "conda install pytest" or "pip install pytest" +pytest -v tests +pytest -v tests/unit/test_indicator_node.py + +''' +import warnings +import unittest +import cudf +import gquant.cuindicator as gi +from gquant.plugin_nodes.transform.indicatorNode import IndicatorNode +from gquant.dataframe_flow.task import Task +from .utils import make_orderer +import numpy as np +import copy + +ordered, compare = make_orderer() +unittest.defaultTestLoader.sortTestMethodsUsing = compare + + +class TestIndicatorNode(unittest.TestCase): + + def setUp(self): + warnings.simplefilter('ignore', category=ImportWarning) + warnings.simplefilter('ignore', category=DeprecationWarning) + # ignore importlib warnings. + size = 200 + half = size // 2 + self.size = size + self.half = half + np.random.seed(10) + random_array = np.random.rand(size) + open_array = np.random.rand(size) + close_array = np.random.rand(size) + high_array = np.random.rand(size) + low_array = np.random.rand(size) + volume_array = np.random.rand(size) + indicator = np.zeros(size, dtype=np.int32) + indicator[0] = 1 + indicator[half] = 1 + df = cudf.dataframe.DataFrame() + df['in'] = random_array + df['open'] = open_array + df['close'] = close_array + df['high'] = high_array + df['low'] = low_array + df['volume'] = volume_array + df['indicator'] = indicator + self._cudf_data = df + self.conf = { + "indicators": [ + {"function": "port_chaikin_oscillator", + "columns": ["high", "low", "close", "volume"], + "args": [10, 20]}, + {"function": "port_bollinger_bands", + "columns": ["close"], + "args": [10], + "outputs": ["b1", "b2"]} + ], + "remove_na": True + } + + def tearDown(self): + pass + + @ordered + def test_colums(self): + '''Test node columns requirments''' + node_obj = {"id": "abc", + "type": "IndicatorNode", + "conf": self.conf, + "inputs": []} + task = Task(node_obj) + inN = IndicatorNode(task) + + col = "indicator" + msg = "bad error: %s is missing" % (col) + self.assertTrue(col in inN.required, msg) + col = "high" + msg = "bad error: %s is missing" % (col) + self.assertTrue(col in inN.required, msg) + col = "low" + msg = "bad error: %s is missing" % (col) + self.assertTrue(col in inN.required, msg) + col = "close" + msg = "bad error: %s is missing" % (col) + self.assertTrue(col in inN.required, msg) + col = "volume" + msg = "bad error: %s is missing" % (col) + self.assertTrue(col in inN.required, msg) + + col = "CH_OS_10_20" + msg = "bad error: %s is missing" % (col) + self.assertTrue(col in inN.addition, msg) + col = "BO_BA_b1_10" + msg = "bad error: %s is missing" % (col) + self.assertTrue(col in inN.addition, msg) + col = "BO_BA_b2_10" + msg = "bad error: %s is missing" % (col) + self.assertTrue(col in inN.addition, msg) + + @ordered + def test_drop(self): + '''Test node columns drop''' + node_obj = {"id": "abc", + "type": "IndicatorNode", + "conf": self.conf, + "inputs": []} + task = Task(node_obj) + inN = IndicatorNode(task) + o = inN.process([self._cudf_data]) + msg = "bad error: df len %d is not right" % (len(o)) + self.assertTrue(len(o) == 162, msg) + + newConf = copy.deepcopy(self.conf) + newConf['remove_na'] = False + node_obj = {"id": "abc", + "type": "IndicatorNode", + "conf": newConf, + "inputs": []} + task = Task(node_obj) + inN = IndicatorNode(task) + o = inN.process([self._cudf_data]) + msg = "bad error: df len %d is not right" % (len(o)) + self.assertTrue(len(o) == 200, msg) + + @ordered + def test_signal(self): + '''Test signal computation''' + + newConf = copy.deepcopy(self.conf) + newConf['remove_na'] = False + node_obj = {"id": "abc", + "type": "IndicatorNode", + "conf": newConf, + "inputs": []} + task = Task(node_obj) + inN = IndicatorNode(task) + o = inN.process([self._cudf_data]) + # check chaikin oscillator computation + r_cudf = gi.chaikin_oscillator(self._cudf_data[:self.half]['high'], + self._cudf_data[:self.half]['low'], + self._cudf_data[:self.half]['close'], + self._cudf_data[:self.half]['volume'], + 10, 20) + computed = o[:self.half]['CH_OS_10_20'].to_array('pandas') + ref = r_cudf.to_array('pandas') + err = np.abs(computed[~np.isnan(computed)] - ref[~np.isnan(ref)]).max() + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + r_cudf = gi.chaikin_oscillator(self._cudf_data[self.half:]['high'], + self._cudf_data[self.half:]['low'], + self._cudf_data[self.half:]['close'], + self._cudf_data[self.half:]['volume'], + 10, 20) + computed = o[self.half:]['CH_OS_10_20'].to_array('pandas') + ref = r_cudf.to_array('pandas') + err = np.abs(computed[~np.isnan(computed)] - ref[~np.isnan(ref)]).max() + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + # check bollinger bands computation + r_cudf = gi.bollinger_bands(self._cudf_data[:self.half]['close'], 10) + computed = o[:self.half]["BO_BA_b1_10"].to_array('pandas') + ref = r_cudf.b1.to_array('pandas') + err = np.abs(computed[~np.isnan(computed)] - ref[~np.isnan(ref)]).max() + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + computed = o[:self.half]["BO_BA_b2_10"].to_array('pandas') + ref = r_cudf.b2.to_array('pandas') + err = np.abs(computed[~np.isnan(computed)] - ref[~np.isnan(ref)]).max() + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + r_cudf = gi.bollinger_bands(self._cudf_data[self.half:]['close'], 10) + computed = o[self.half:]["BO_BA_b1_10"].to_array('pandas') + ref = r_cudf.b1.to_array('pandas') + err = np.abs(computed[~np.isnan(computed)] - ref[~np.isnan(ref)]).max() + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + computed = o[self.half:]["BO_BA_b2_10"].to_array('pandas') + ref = r_cudf.b2.to_array('pandas') + err = np.abs(computed[~np.isnan(computed)] - ref[~np.isnan(ref)]).max() + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/unit/test_multi_assets_indicator.py b/tests/unit/test_multi_assets_indicator.py new file mode 100644 index 00000000..550e4eed --- /dev/null +++ b/tests/unit/test_multi_assets_indicator.py @@ -0,0 +1,790 @@ +''' +Technical Indicator for Multiple Assets Unit Tests + +To run unittests: + +# Using standard library unittest + +python -m unittest -v +python -m unittest tests/unit/test_multi_assets_indicator.py -v + +or + +python -m unittest discover +python -m unittest discover -s -p 'test_*.py' + +# Using pytest +# "conda install pytest" or "pip install pytest" +pytest -v tests +pytest -v tests/unit/test_multi_assets_indicator.py + +''' +import pandas as pd +import unittest +import cudf +from .utils import make_orderer, error_function +import gquant.cuindicator as gi +from . import technical_indicators as ti +from gquant.cuindicator import PEwm +import numpy as np +import warnings + +ordered, compare = make_orderer() +unittest.defaultTestLoader.sortTestMethodsUsing = compare + + +class TestMultipleAssets(unittest.TestCase): + + def setUp(self): + warnings.filterwarnings('ignore', message='numpy.ufunc size changed') + warnings.simplefilter('ignore', category=ImportWarning) + warnings.simplefilter('ignore', category=DeprecationWarning) + size = 200 + half = size // 2 + self.size = size + self.half = half + np.random.seed(10) + random_array = np.random.rand(size) + open_array = np.random.rand(size) + close_array = np.random.rand(size) + high_array = np.random.rand(size) + low_array = np.random.rand(size) + volume_array = np.random.rand(size) + indicator = np.zeros(size, dtype=np.int32) + indicator[0] = 1 + indicator[half] = 1 + df = cudf.dataframe.DataFrame() + df['in'] = random_array + df['open'] = open_array + df['close'] = close_array + df['high'] = high_array + df['low'] = low_array + df['volume'] = volume_array + df['indicator'] = indicator + + pdf = pd.DataFrame() + pdf['in0'] = random_array[0:half] + pdf['in1'] = random_array[half:] + + low_pdf = pd.DataFrame() + high_pdf = pd.DataFrame() + + low_pdf['Open'] = open_array[0:half] + low_pdf['Close'] = close_array[0:half] + low_pdf['High'] = high_array[0:half] + low_pdf['Low'] = low_array[0:half] + low_pdf['Volume'] = volume_array[0:half] + + high_pdf['Open'] = open_array[half:] + high_pdf['Close'] = close_array[half:] + high_pdf['High'] = high_array[half:] + high_pdf['Low'] = low_array[half:] + high_pdf['Volume'] = volume_array[half:] + + self._pandas_data = pdf + self._cudf_data = df + self._plow_data = low_pdf + self._phigh_data = high_pdf + + def tearDown(self): + pass + + @ordered + def test_multi_assets_indicator(self): + '''Test portfolio ewm method''' + self._cudf_data['ewma'] = PEwm(3, + self._cudf_data['in'], + self._cudf_data[ + 'indicator'].data.to_gpu_array(), + thread_tile=2, + number_of_threads=2).mean() + gpu_array = self._cudf_data['ewma'] + gpu_result = gpu_array[0:self.half] + cpu_result = self._pandas_data['in0'].ewm(span=3, + min_periods=3).mean() + err = error_function(gpu_result, cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = self._pandas_data['in1'].ewm(span=3, + min_periods=3).mean() + gpu_result = gpu_array[self.half:] + err = error_function(gpu_result, cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_macd(self): + '''Test portfolio macd method''' + n_fast = 10 + n_slow = 20 + r = gi.port_macd(self._cudf_data['indicator'].data.to_gpu_array(), + self._cudf_data['close'].data.to_gpu_array(), + n_fast, + n_slow) + cpu_result = ti.macd(self._plow_data, n_fast, n_slow) + err = error_function(r.MACD[:self.half], cpu_result['MACD_10_20']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + err = error_function(r.MACDsign[:self.half], + cpu_result['MACDsign_10_20']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + err = error_function(r.MACDdiff[:self.half], + cpu_result['MACDdiff_10_20']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.macd(self._phigh_data, n_fast, n_slow) + err = error_function(r.MACD[self.half:], cpu_result['MACD_10_20']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + err = error_function(r.MACDsign[self.half:], + cpu_result['MACDsign_10_20']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + err = error_function(r.MACDdiff[self.half:], + cpu_result['MACDdiff_10_20']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_relative_strength_index(self): + '''Test portfolio relative strength index method''' + n = 10 + r = gi.port_relative_strength_index( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + n) + + cpu_result = ti.relative_strength_index(self._plow_data, n) + err = error_function(r[:self.half], cpu_result['RSI_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.relative_strength_index(self._phigh_data, n) + err = error_function(r[self.half:], cpu_result['RSI_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_trix(self): + '''Test portfolio trix''' + n = 3 + + r = gi.port_trix(self._cudf_data['indicator'], + self._cudf_data['close'], + n) + + cpu_result = ti.trix(self._plow_data, n) + err = error_function(r[:self.half], cpu_result['Trix_3']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.trix(self._phigh_data, n) + err = error_function(r[self.half:], cpu_result['Trix_3']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_average_true_range(self): + '''Test portfolio average true range''' + n = 10 + r = gi.port_average_true_range(self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close'], 10) + + cpu_result = ti.average_true_range(self._plow_data, n) + err = error_function(r[:self.half], cpu_result['ATR_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.average_true_range(self._phigh_data, n) + err = error_function(r[self.half:], cpu_result['ATR_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_ppsr(self): + '''Test portfolio average true range''' + r = gi.port_ppsr(self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close']) + + cpu_result = ti.ppsr(self._plow_data) + err = error_function(r.PP[:self.half], cpu_result['PP']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.R1[:self.half], cpu_result['R1']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.S1[:self.half], cpu_result['S1']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.R2[:self.half], cpu_result['R2']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.S2[:self.half], cpu_result['S2']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.R3[:self.half], cpu_result['R3']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.S3[:self.half], cpu_result['S3']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.ppsr(self._phigh_data) + err = error_function(r.PP[self.half:], cpu_result['PP']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.R1[self.half:], cpu_result['R1']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.S1[self.half:], cpu_result['S1']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.R2[self.half:], cpu_result['R2']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.S2[self.half:], cpu_result['S2']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.R3[self.half:], cpu_result['R3']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.S3[self.half:], cpu_result['S3']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_stochastic_oscillator_k(self): + '''Test portfolio stochastic oscillator''' + r = gi.port_stochastic_oscillator_k(self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close']) + + cpu_result = ti.stochastic_oscillator_k(self._plow_data) + err = error_function(r[:self.half], cpu_result['SO%k']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.stochastic_oscillator_k(self._phigh_data) + err = error_function(r[self.half:], cpu_result['SO%k']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_stochastic_oscillator_d(self): + '''Test portfolio stochastic oscillator''' + n = 10 + r = gi.port_stochastic_oscillator_d(self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close'], + n) + + cpu_result = ti.stochastic_oscillator_d(self._plow_data, n) + err = error_function(r[:self.half], cpu_result['SO%d_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.stochastic_oscillator_d(self._phigh_data, n) + err = error_function(r[self.half:], cpu_result['SO%d_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_moving_average(self): + '''Test portfolio moving average''' + n = 10 + r = gi.port_moving_average(self._cudf_data['indicator'], + self._cudf_data['close'], + n) + + cpu_result = ti.moving_average(self._plow_data, n) + err = error_function(r[:self.half], cpu_result['MA_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.moving_average(self._phigh_data, n) + err = error_function(r[self.half:], cpu_result['MA_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_rate_of_change(self): + '''Test portfolio rate_of_change''' + n = 10 + r = gi.port_rate_of_change(self._cudf_data['indicator'], + self._cudf_data['close'], + n) + + cpu_result = ti.rate_of_change(self._plow_data, n) + err = error_function(r[:self.half], cpu_result['ROC_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.rate_of_change(self._phigh_data, n) + err = error_function(r[self.half:], cpu_result['ROC_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + n = -10 + r = gi.port_rate_of_change(self._cudf_data['indicator'], + self._cudf_data['close'], + n) + + cpu_result = ti.rate_of_change(self._plow_data, n) + err = error_function(r[:self.half], cpu_result['ROC_-10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.rate_of_change(self._phigh_data, n) + err = error_function(r[self.half:], cpu_result['ROC_-10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_diff(self): + '''Test portfolio diff''' + n = 10 + r = gi.port_diff(self._cudf_data['indicator'], + self._cudf_data['close'], + n) + + cpu_result = self._plow_data['Close'].diff(n) + err = error_function(r[:self.half], cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = self._phigh_data['Close'].diff(n) + err = error_function(r[self.half:], cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + n = -10 + r = gi.port_diff(self._cudf_data['indicator'], + self._cudf_data['close'], + n) + + cpu_result = self._plow_data['Close'].diff(n) + err = error_function(r[:self.half], cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = self._phigh_data['Close'].diff(n) + err = error_function(r[self.half:], cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_shift(self): + '''Test portfolio shift''' + n = 10 + r = gi.port_shift(self._cudf_data['indicator'], + self._cudf_data['close'], + n) + + cpu_result = self._plow_data['Close'].shift(n) + err = error_function(r[:self.half], cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = self._phigh_data['Close'].shift(n) + err = error_function(r[self.half:], cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + n = -10 + r = gi.port_shift(self._cudf_data['indicator'], + self._cudf_data['close'], + n) + + cpu_result = self._plow_data['Close'].shift(n) + err = error_function(r[:self.half], cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = self._phigh_data['Close'].shift(n) + err = error_function(r[self.half:], cpu_result) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_bollinger_bands(self): + '''Test portfolio bollinger bands''' + n = 10 + r = gi.port_bollinger_bands(self._cudf_data['indicator'], + self._cudf_data['close'], + n) + + cpu_result = ti.bollinger_bands(self._plow_data, n) + err = error_function(r.b1[:self.half], cpu_result['BollingerB_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.b2[:self.half], cpu_result['Bollinger%b_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.bollinger_bands(self._phigh_data, n) + err = error_function(r.b1[self.half:], cpu_result['BollingerB_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.b2[self.half:], cpu_result['Bollinger%b_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_average_directional_movement_index(self): + '''Test portfolio average directional movement index''' + n = 10 + n_adx = 20 + r = gi.port_average_directional_movement_index( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close'], + n, n_adx) + + cpu_result = ti.average_directional_movement_index(self._plow_data, + n, + n_adx) + err = error_function(r[:self.half], cpu_result['ADX_10_20']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.average_directional_movement_index(self._phigh_data, + n, + n_adx) + err = error_function(r[self.half:], cpu_result['ADX_10_20']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_vortex_indicator(self): + '''Test portfolio vortex indicator''' + n = 10 + r = gi.port_vortex_indicator( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close'], + n) + + cpu_result = ti.vortex_indicator(self._plow_data, + n) + err = error_function(r[:self.half], cpu_result['Vortex_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.vortex_indicator(self._phigh_data, + n) + err = error_function(r[self.half:], cpu_result['Vortex_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_kst_oscillator(self): + '''Test portfolio kst oscillator''' + + r = gi.port_kst_oscillator( + self._cudf_data['indicator'], + self._cudf_data['close'], 3, 4, 5, 6, 7, 8, 9, 10) + + cpu_result = ti.kst_oscillator(self._plow_data, + 3, 4, 5, 6, 7, 8, 9, 10) + err = error_function(r[:self.half], cpu_result['KST_3_4_5_6_7_8_9_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.kst_oscillator(self._phigh_data, + 3, 4, 5, 6, 7, 8, 9, 10) + err = error_function(r[self.half:], cpu_result['KST_3_4_5_6_7_8_9_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_mass_index(self): + '''Test portfolio mass index''' + + r = gi.port_mass_index( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + 9, 25) + + cpu_result = ti.mass_index(self._plow_data) + err = error_function(r[:self.half], cpu_result['Mass Index']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.mass_index(self._phigh_data) + err = error_function(r[self.half:], cpu_result['Mass Index']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_true_strength_index(self): + '''Test portfolio true strength index''' + + r = gi.port_true_strength_index( + self._cudf_data['indicator'], + self._cudf_data['close'], + 5, 8) + + cpu_result = ti.true_strength_index(self._plow_data, 5, 8) + err = error_function(r[:self.half], cpu_result['TSI_5_8']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.true_strength_index(self._phigh_data, 5, 8) + err = error_function(r[self.half:], cpu_result['TSI_5_8']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_chaikin_oscillator(self): + '''Test portfolio chaikin oscillator''' + + r = gi.port_chaikin_oscillator( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close'], + self._cudf_data['volume'], + 3, 10) + + cpu_result = ti.chaikin_oscillator(self._plow_data) + err = error_function(r[:self.half], cpu_result['Chaikin']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.chaikin_oscillator(self._phigh_data) + err = error_function(r[self.half:], cpu_result['Chaikin']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_money_flow_index(self): + '''Test portfolio money flow index''' + + r = gi.port_money_flow_index( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close'], + self._cudf_data['volume'], + 10) + + cpu_result = ti.money_flow_index(self._plow_data, 10) + err = error_function(r[:self.half], cpu_result['MFI_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.money_flow_index(self._phigh_data, 10) + err = error_function(r[self.half:], cpu_result['MFI_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_on_balance_volume(self): + '''Test portfolio on balance volume''' + + r = gi.port_on_balance_volume( + self._cudf_data['indicator'], + self._cudf_data['close'], + self._cudf_data['volume'], + 10) + + cpu_result = ti.on_balance_volume(self._plow_data, 10) + err = error_function(r[:self.half], cpu_result['OBV_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.on_balance_volume(self._phigh_data, 10) + err = error_function(r[self.half:], cpu_result['OBV_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_force_index(self): + '''Test portfolio force index''' + + r = gi.port_force_index( + self._cudf_data['indicator'], + self._cudf_data['close'], + self._cudf_data['volume'], + 10) + + cpu_result = ti.force_index(self._plow_data, 10) + err = error_function(r[:self.half], cpu_result['Force_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.force_index(self._phigh_data, 10) + err = error_function(r[self.half:], cpu_result['Force_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_ease_of_movement(self): + '''Test portfolio ease of movement''' + + r = gi.port_ease_of_movement( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['volume'], + 10) + + cpu_result = ti.ease_of_movement(self._plow_data, 10) + err = error_function(r[:self.half], cpu_result['EoM_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.ease_of_movement(self._phigh_data, 10) + err = error_function(r[self.half:], cpu_result['EoM_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_ultimate_oscillator(self): + '''Test portfolio ultimate oscillator''' + + r = gi.port_ultimate_oscillator( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close']) + + cpu_result = ti.ultimate_oscillator(self._plow_data) + err = error_function(r[:self.half], cpu_result['Ultimate_Osc']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.ultimate_oscillator(self._phigh_data) + err = error_function(r[self.half:], cpu_result['Ultimate_Osc']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_donchian_channel(self): + '''Test portfolio donchian channel''' + + r = gi.port_donchian_channel( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + 10) + cpu_result = ti.donchian_channel(self._plow_data, 10) + err = error_function(r[:self.half-1], cpu_result['Donchian_10'][0:99]) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.donchian_channel(self._phigh_data, 10) + err = error_function(r[self.half:-1], cpu_result['Donchian_10'][0:99]) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_coppock_curve(self): + '''Test portfolio coppock curve''' + + r = gi.port_coppock_curve( + self._cudf_data['indicator'], + self._cudf_data['close'], + 10) + cpu_result = ti.coppock_curve(self._plow_data, 10) + err = error_function(r[:self.half], cpu_result['Copp_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.coppock_curve(self._phigh_data, 10) + err = error_function(r[self.half:], cpu_result['Copp_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_accumulation_distribution(self): + '''Test portfolio accumulation distribution''' + + r = gi.port_accumulation_distribution( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close'], + self._cudf_data['volume'], + 10) + cpu_result = ti.accumulation_distribution(self._plow_data, 10) + err = error_function(r[:self.half], cpu_result['Acc/Dist_ROC_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.accumulation_distribution(self._phigh_data, 10) + err = error_function(r[self.half:], cpu_result['Acc/Dist_ROC_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_commodity_channel_index(self): + '''Test portfolio commodity channel index''' + + r = gi.port_commodity_channel_index( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close'], + 10) + cpu_result = ti.commodity_channel_index(self._plow_data, 10) + err = error_function(r[:self.half], cpu_result['CCI_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + cpu_result = ti.commodity_channel_index(self._phigh_data, 10) + err = error_function(r[self.half:], cpu_result['CCI_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + @ordered + def test_port_keltner_channel(self): + '''Test portfolio keltner channel''' + + r = gi.port_keltner_channel( + self._cudf_data['indicator'], + self._cudf_data['high'], + self._cudf_data['low'], + self._cudf_data['close'], + 10) + cpu_result = ti.keltner_channel(self._plow_data, 10) + err = error_function(r.KelChD[:self.half], cpu_result['KelChD_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.KelChM[:self.half], cpu_result['KelChM_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.KelChU[:self.half], cpu_result['KelChU_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + cpu_result = ti.keltner_channel(self._phigh_data, 10) + err = error_function(r.KelChD[self.half:], cpu_result['KelChD_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.KelChM[self.half:], cpu_result['KelChM_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + err = error_function(r.KelChU[self.half:], cpu_result['KelChU_10']) + msg = "bad error %f\n" % (err,) + self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/unit/test_pewm.py b/tests/unit/test_pewm.py deleted file mode 100644 index 901a687f..00000000 --- a/tests/unit/test_pewm.py +++ /dev/null @@ -1,81 +0,0 @@ -''' -Workflow Serialization Unit Tests - -To run unittests: - -# Using standard library unittest - -python -m unittest -v -python -m unittest tests/unit/test_pewm.py -v - -or - -python -m unittest discover -python -m unittest discover -s -p 'test_*.py' - -# Using pytest -# "conda install pytest" or "pip install pytest" -pytest -v tests -pytest -v tests/unit/test_pewm.py - -''' -import pandas as pd -import unittest -import cudf -from .utils import make_orderer, error_function -from gquant.cuindicator import PEwm -import numpy as np - -ordered, compare = make_orderer() -unittest.defaultTestLoader.sortTestMethodsUsing = compare - - -class TestPEwm(unittest.TestCase): - - def setUp(self): - random_array = np.arange(20, dtype=np.float64) - indicator = np.zeros(20, dtype=np.int32) - indicator[0] = 1 - indicator[10] = 1 - df = cudf.dataframe.DataFrame() - df['in'] = random_array - df['indicator'] = indicator - - pdf = pd.DataFrame() - pdf['in0'] = random_array[0:10] - pdf['in1'] = random_array[10:] - - # ignore importlib warnings. - self._pandas_data = pdf - self._cudf_data = df - - def tearDown(self): - pass - - @ordered - def test_pewm(self): - '''Test portfolio ewm method''' - self._cudf_data['ewma'] = PEwm(3, - self._cudf_data['in'], - self._cudf_data[ - 'indicator'].data.to_gpu_array(), - thread_tile=2, - number_of_threads=2).mean() - gpu_array = self._cudf_data['ewma'] - gpu_result = gpu_array[0:10] - cpu_result = self._pandas_data['in0'].ewm(span=3, - min_periods=3).mean() - err = error_function(gpu_result, cpu_result) - msg = "bad error %f\n" % (err,) - self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) - - cpu_result = self._pandas_data['in1'].ewm(span=3, - min_periods=3).mean() - gpu_result = gpu_array[10:20] - err = error_function(gpu_result, cpu_result) - msg = "bad error %f\n" % (err,) - self.assertTrue(np.isclose(err, 0, atol=1e-6), msg) - - -if __name__ == '__main__': - unittest.main() diff --git a/tests/unit/test_workflow_serialization.py b/tests/unit/test_workflow_serialization.py index 69135029..6d564635 100644 --- a/tests/unit/test_workflow_serialization.py +++ b/tests/unit/test_workflow_serialization.py @@ -98,9 +98,10 @@ def tearDown(self): @ordered def test_save_workflow(self): '''Test saving a workflow to yaml:''' - from gquant.dataframe_flow.workflow import save_workflow + from gquant.dataframe_flow import TaskGraph + task_graph = TaskGraph(self._task_list) workflow_file = os.path.join(self._test_dir, 'test_save_workflow.yaml') - save_workflow(self._task_list, workflow_file) + task_graph.save_taskgraph(workflow_file) with open(workflow_file) as wf: workflow_str = wf.read() @@ -123,21 +124,21 @@ def test_save_workflow(self): @ordered def test_load_workflow(self): '''Test loading a workflow from yaml:''' - from gquant.dataframe_flow.workflow import load_workflow + from gquant.dataframe_flow import TaskGraph workflow_file = os.path.join(self._test_dir, 'test_save_workflow.yaml') with open(workflow_file, 'w') as wf: wf.write(WORKFLOW_YAML) - task_list = load_workflow(workflow_file) + task_list = TaskGraph.load_taskgraph(workflow_file) all_tasks_exist = True - for itask in self._task_list: - if itask not in task_list: + for t in task_list: + match = False + if t._task_spec in self._task_list: + match = True + if not match: all_tasks_exist = False break - - # all_tasks_exist = False # Testing when test fails. - with StringIO() as yf: yaml.dump(self._task_list, yf, default_flow_style=False, sort_keys=False) diff --git a/util/print_env.sh b/util/print_env.sh new file mode 100755 index 00000000..551dca65 --- /dev/null +++ b/util/print_env.sh @@ -0,0 +1,87 @@ +#!/usr/bin/env bash +# Reports relevant environment information useful for diagnosing and +# debugging gQuant issues. +# Usage: +# "./print_env.sh" - prints to stdout +# "./print_env.sh > env.txt" - prints to file "env.txt" + +print_env() { + echo "**git***" + if [ "$(git rev-parse --is-inside-work-tree 2>/dev/null)" == "true" ]; then + git log --decorate -n 1 + echo "**git submodules***" + git submodule status --recursive + else + echo "Not inside a git repository" + fi + echo + + echo "***OS Information***" + cat /etc/*-release + uname -a + echo + + echo "***GPU Information***" + nvidia-smi + echo + + echo "***CPU***" + lscpu + echo + + echo "***CMake***" + which cmake && cmake --version + echo + + echo "***g++***" + which g++ && g++ --version + echo + + echo "***nvcc***" + which nvcc && nvcc --version + echo + + echo "***Python***" + which python && python -c "import sys; print('Python {0}.{1}.{2}'.format(sys.version_info[0], sys.version_info[1], sys.version_info[2]))" + echo + + echo "***Environment Variables***" + + printf '%-32s: %s\n' PATH $PATH + + printf '%-32s: %s\n' LD_LIBRARY_PATH $LD_LIBRARY_PATH + + printf '%-32s: %s\n' NUMBAPRO_NVVM $NUMBAPRO_NVVM + + printf '%-32s: %s\n' NUMBAPRO_LIBDEVICE $NUMBAPRO_LIBDEVICE + + printf '%-32s: %s\n' CONDA_PREFIX $CONDA_PREFIX + + printf '%-32s: %s\n' PYTHON_PATH $PYTHON_PATH + + echo + + + # Print conda packages if conda exists + if type "conda" &> /dev/null; then + echo '***conda packages***' + which conda && conda list + echo + # Print pip packages if pip exists + elif type "pip" &> /dev/null; then + echo "conda not found" + echo "***pip packages***" + which pip && pip list + echo + else + echo "conda not found" + echo "pip not found" + fi +} + +echo "
Click here to see environment details
"
+echo "     "
+print_env | while read -r line; do
+    echo "     $line"
+done
+echo "
"