{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Lab 5 - Julia Code" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Authors: Valerie Dube, Erzo Garay, Juan Marcos Guerrero y Matias Villalba" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Libraries\n", "using DataFrames\n", "using CSV\n", "using StatsPlots\n", "using Statistics\n", "\n", "using StatsModels\n", "using GLM" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
5×15 DataFrame
Rowywgender_femalegender_malegender_transgenderethnicgrp_asianethnicgrp_blackethnicgrp_mixed_multipleethnicgrp_otherethnicgrp_whitepartners1postlaunchmsmageimd_decile
Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64
11101000100010275
20001000001000196
30101001000010264
40010000001100202
51110010000010243
" ], "text/latex": [ "\\begin{tabular}{r|cccccccc}\n", "\t& y & w & gender\\_female & gender\\_male & gender\\_transgender & ethnicgrp\\_asian & ethnicgrp\\_black & \\\\\n", "\t\\hline\n", "\t& Int64 & Int64 & Int64 & Int64 & Int64 & Int64 & Int64 & \\\\\n", "\t\\hline\n", "\t1 & 1 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t2 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t3 & 0 & 1 & 0 & 1 & 0 & 0 & 1 & $\\dots$ \\\\\n", "\t4 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t5 & 1 & 1 & 1 & 0 & 0 & 1 & 0 & $\\dots$ \\\\\n", "\\end{tabular}\n" ], "text/plain": [ "\u001b[1m5×15 DataFrame\u001b[0m\n", "\u001b[1m Row \u001b[0m│\u001b[1m y \u001b[0m\u001b[1m w \u001b[0m\u001b[1m gender_female \u001b[0m\u001b[1m gender_male \u001b[0m\u001b[1m gender_transgender \u001b[0m\u001b[1m ethnicgrp\u001b[0m ⋯\n", " │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m ⋯\n", "─────┼──────────────────────────────────────────────────────────────────────────\n", " 1 │ 1 1 0 1 0 ⋯\n", " 2 │ 0 0 0 1 0\n", " 3 │ 0 1 0 1 0\n", " 4 │ 0 0 1 0 0\n", " 5 │ 1 1 1 0 0 ⋯\n", "\u001b[36m 10 columns omitted\u001b[0m" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Import data and see first observations\n", "df = CSV.read(\"../../data/processed_esti.csv\", DataFrame)\n", "first(df, 5)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
15×7 DataFrame
Rowvariablemeanminmedianmaxnmissingeltype
SymbolFloat64Int64Float64Int64Int64DataType
1y0.35192600.010Int64
2w0.52961501.010Int64
3gender_female0.58424401.010Int64
4gender_male0.41345600.010Int64
5gender_transgender0.0023001700.010Int64
6ethnicgrp_asian0.063829800.010Int64
7ethnicgrp_black0.086256500.010Int64
8ethnicgrp_mixed_multiple0.088556600.010Int64
9ethnicgrp_other0.01322600.010Int64
10ethnicgrp_white0.74813101.010Int64
11partners10.29672200.010Int64
12postlaunch0.51696401.010Int64
13msm0.13053500.010Int64
14age23.10641623.0300Int64
15imd_decile3.4715413.090Int64
" ], "text/latex": [ "\\begin{tabular}{r|ccccccc}\n", "\t& variable & mean & min & median & max & nmissing & eltype\\\\\n", "\t\\hline\n", "\t& Symbol & Float64 & Int64 & Float64 & Int64 & Int64 & DataType\\\\\n", "\t\\hline\n", "\t1 & y & 0.351926 & 0 & 0.0 & 1 & 0 & Int64 \\\\\n", "\t2 & w & 0.529615 & 0 & 1.0 & 1 & 0 & Int64 \\\\\n", "\t3 & gender\\_female & 0.584244 & 0 & 1.0 & 1 & 0 & Int64 \\\\\n", "\t4 & gender\\_male & 0.413456 & 0 & 0.0 & 1 & 0 & Int64 \\\\\n", "\t5 & gender\\_transgender & 0.00230017 & 0 & 0.0 & 1 & 0 & Int64 \\\\\n", "\t6 & ethnicgrp\\_asian & 0.0638298 & 0 & 0.0 & 1 & 0 & Int64 \\\\\n", "\t7 & ethnicgrp\\_black & 0.0862565 & 0 & 0.0 & 1 & 0 & Int64 \\\\\n", "\t8 & ethnicgrp\\_mixed\\_multiple & 0.0885566 & 0 & 0.0 & 1 & 0 & Int64 \\\\\n", "\t9 & ethnicgrp\\_other & 0.013226 & 0 & 0.0 & 1 & 0 & Int64 \\\\\n", "\t10 & ethnicgrp\\_white & 0.748131 & 0 & 1.0 & 1 & 0 & Int64 \\\\\n", "\t11 & partners1 & 0.296722 & 0 & 0.0 & 1 & 0 & Int64 \\\\\n", "\t12 & postlaunch & 0.516964 & 0 & 1.0 & 1 & 0 & Int64 \\\\\n", "\t13 & msm & 0.130535 & 0 & 0.0 & 1 & 0 & Int64 \\\\\n", "\t14 & age & 23.1064 & 16 & 23.0 & 30 & 0 & Int64 \\\\\n", "\t15 & imd\\_decile & 3.47154 & 1 & 3.0 & 9 & 0 & Int64 \\\\\n", "\\end{tabular}\n" ], "text/plain": [ "\u001b[1m15×7 DataFrame\u001b[0m\n", "\u001b[1m Row \u001b[0m│\u001b[1m variable \u001b[0m\u001b[1m mean \u001b[0m\u001b[1m min \u001b[0m\u001b[1m median \u001b[0m\u001b[1m max \u001b[0m\u001b[1m nmissing \u001b[0m\u001b[1m\u001b[0m ⋯\n", " │\u001b[90m Symbol \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m\u001b[0m ⋯\n", "─────┼──────────────────────────────────────────────────────────────────────────\n", " 1 │ y 0.351926 0 0.0 1 0 ⋯\n", " 2 │ w 0.529615 0 1.0 1 0\n", " 3 │ gender_female 0.584244 0 1.0 1 0\n", " 4 │ gender_male 0.413456 0 0.0 1 0\n", " 5 │ gender_transgender 0.00230017 0 0.0 1 0 ⋯\n", " 6 │ ethnicgrp_asian 0.0638298 0 0.0 1 0\n", " 7 │ ethnicgrp_black 0.0862565 0 0.0 1 0\n", " 8 │ ethnicgrp_mixed_multiple 0.0885566 0 0.0 1 0\n", " 9 │ ethnicgrp_other 0.013226 0 0.0 1 0 ⋯\n", " 10 │ ethnicgrp_white 0.748131 0 1.0 1 0\n", " 11 │ partners1 0.296722 0 0.0 1 0\n", " 12 │ postlaunch 0.516964 0 1.0 1 0\n", " 13 │ msm 0.130535 0 0.0 1 0 ⋯\n", " 14 │ age 23.1064 16 23.0 30 0\n", " 15 │ imd_decile 3.47154 1 3.0 9 0\n", "\u001b[36m 1 column omitted\u001b[0m" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "describe(df)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
921×14 DataFrame
896 rows omitted
Rowwgender_femalegender_malegender_transgenderethnicgrp_asianethnicgrp_blackethnicgrp_mixed_multipleethnicgrp_otherethnicgrp_whitepartners1postlaunchmsmageimd_decile
Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64Int64
1101000100010275
2101001000010264
3110010000010243
4101000001010242
5110000001000244
6101000001100272
7110001000000216
8101000001001184
9101000001111262
10101000001011236
11110000100110244
12110001000010263
13110000001000263
⋮⋮⋮⋮⋮⋮⋮⋮⋮⋮⋮⋮⋮⋮⋮
910110010000100284
911101000001010252
912110001000100182
913101000001011264
914101000001010213
915101000001000194
916101000001000212
917110000100110263
918110001000110291
919110000001010274
920110000001110254
921110000001010254
" ], "text/latex": [ "\\begin{tabular}{r|ccccccc}\n", "\t& w & gender\\_female & gender\\_male & gender\\_transgender & ethnicgrp\\_asian & ethnicgrp\\_black & \\\\\n", "\t\\hline\n", "\t& Int64 & Int64 & Int64 & Int64 & Int64 & Int64 & \\\\\n", "\t\\hline\n", "\t1 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t2 & 1 & 0 & 1 & 0 & 0 & 1 & $\\dots$ \\\\\n", "\t3 & 1 & 1 & 0 & 0 & 1 & 0 & $\\dots$ \\\\\n", "\t4 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t5 & 1 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t6 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t7 & 1 & 1 & 0 & 0 & 0 & 1 & $\\dots$ \\\\\n", "\t8 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t9 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t10 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t11 & 1 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t12 & 1 & 1 & 0 & 0 & 0 & 1 & $\\dots$ \\\\\n", "\t13 & 1 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t14 & 1 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t15 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t16 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t17 & 1 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t18 & 1 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t19 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t20 & 1 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t21 & 1 & 0 & 1 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t22 & 1 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t23 & 1 & 1 & 0 & 0 & 0 & 0 & $\\dots$ \\\\\n", "\t24 & 1 & 0 & 1 & 0 & 0 & 1 & $\\dots$ \\\\\n", "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & \\\\\n", "\\end{tabular}\n" ], "text/plain": [ "\u001b[1m921×14 DataFrame\u001b[0m\n", "\u001b[1m Row \u001b[0m│\u001b[1m w \u001b[0m\u001b[1m gender_female \u001b[0m\u001b[1m gender_male \u001b[0m\u001b[1m gender_transgender \u001b[0m\u001b[1m ethnicgrp_asian \u001b[0m\u001b[1m\u001b[0m ⋯\n", " │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m\u001b[0m ⋯\n", "─────┼──────────────────────────────────────────────────────────────────────────\n", " 1 │ 1 0 1 0 0 ⋯\n", " 2 │ 1 0 1 0 0\n", " 3 │ 1 1 0 0 1\n", " 4 │ 1 0 1 0 0\n", " 5 │ 1 1 0 0 0 ⋯\n", " 6 │ 1 0 1 0 0\n", " 7 │ 1 1 0 0 0\n", " 8 │ 1 0 1 0 0\n", " ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮ ⋱\n", " 915 │ 1 0 1 0 0 ⋯\n", " 916 │ 1 0 1 0 0\n", " 917 │ 1 1 0 0 0\n", " 918 │ 1 1 0 0 0\n", " 919 │ 1 1 0 0 0 ⋯\n", " 920 │ 1 1 0 0 0\n", " 921 │ 1 1 0 0 0\n", "\u001b[36m 9 columns and 906 rows omitted\u001b[0m" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "control = select(filter(row -> row[:w] == 0, df), Not(:y))\n", "treatment = select(filter(row -> row[:w] == 1, df), Not(:y))" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "get_descriptive_stats (generic function with 1 method)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "using DataFrames, Statistics\n", "\n", "# Function to get descriptive statistics\n", "function get_descriptive_stats(group::DataFrame, column::Symbol)\n", " if column == :age\n", " count_val = count(!ismissing, group[:, column])\n", " else\n", " count_val = sum(group[:, column] .== 1)\n", " end\n", " mean_val = mean(group[:, column])\n", " std_val = std(group[:, column])\n", " return count_val, mean_val, std_val\n", "end" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
13×4 DataFrame
RowVariableCountMeanStd
SymbolInt64Float64Float64
1age92123.15853.53874
2ethnicgrp_asian660.07166120.258066
3ethnicgrp_black740.08034740.271978
4ethnicgrp_mixed_multiple780.08469060.278572
5ethnicgrp_other90.009771990.0984226
6ethnicgrp_white6940.7535290.43119
7gender_female5410.5874050.492569
8gender_male3770.4093380.491979
9gender_transgender30.003257330.0570109
10imd_decile363.460371.46584
11msm1140.1237790.329508
12partners12770.300760.458838
13postlaunch5120.5559170.497133
" ], "text/latex": [ "\\begin{tabular}{r|cccc}\n", "\t& Variable & Count & Mean & Std\\\\\n", "\t\\hline\n", "\t& Symbol & Int64 & Float64 & Float64\\\\\n", "\t\\hline\n", "\t1 & age & 921 & 23.1585 & 3.53874 \\\\\n", "\t2 & ethnicgrp\\_asian & 66 & 0.0716612 & 0.258066 \\\\\n", "\t3 & ethnicgrp\\_black & 74 & 0.0803474 & 0.271978 \\\\\n", "\t4 & ethnicgrp\\_mixed\\_multiple & 78 & 0.0846906 & 0.278572 \\\\\n", "\t5 & ethnicgrp\\_other & 9 & 0.00977199 & 0.0984226 \\\\\n", "\t6 & ethnicgrp\\_white & 694 & 0.753529 & 0.43119 \\\\\n", "\t7 & gender\\_female & 541 & 0.587405 & 0.492569 \\\\\n", "\t8 & gender\\_male & 377 & 0.409338 & 0.491979 \\\\\n", "\t9 & gender\\_transgender & 3 & 0.00325733 & 0.0570109 \\\\\n", "\t10 & imd\\_decile & 36 & 3.46037 & 1.46584 \\\\\n", "\t11 & msm & 114 & 0.123779 & 0.329508 \\\\\n", "\t12 & partners1 & 277 & 0.30076 & 0.458838 \\\\\n", "\t13 & postlaunch & 512 & 0.555917 & 0.497133 \\\\\n", "\\end{tabular}\n" ], "text/plain": [ "\u001b[1m13×4 DataFrame\u001b[0m\n", "\u001b[1m Row \u001b[0m│\u001b[1m Variable \u001b[0m\u001b[1m Count \u001b[0m\u001b[1m Mean \u001b[0m\u001b[1m Std \u001b[0m\n", " │\u001b[90m Symbol \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", "─────┼─────────────────────────────────────────────────────────\n", " 1 │ age 921 23.1585 3.53874\n", " 2 │ ethnicgrp_asian 66 0.0716612 0.258066\n", " 3 │ ethnicgrp_black 74 0.0803474 0.271978\n", " 4 │ ethnicgrp_mixed_multiple 78 0.0846906 0.278572\n", " 5 │ ethnicgrp_other 9 0.00977199 0.0984226\n", " 6 │ ethnicgrp_white 694 0.753529 0.43119\n", " 7 │ gender_female 541 0.587405 0.492569\n", " 8 │ gender_male 377 0.409338 0.491979\n", " 9 │ gender_transgender 3 0.00325733 0.0570109\n", " 10 │ imd_decile 36 3.46037 1.46584\n", " 11 │ msm 114 0.123779 0.329508\n", " 12 │ partners1 277 0.30076 0.458838\n", " 13 │ postlaunch 512 0.555917 0.497133" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "variables = setdiff(Symbol.(names(df)), [:w, :y])\n", "control_stats = Dict(var => get_descriptive_stats(control, var) for var in variables)\n", "treatment_stats = Dict(var => get_descriptive_stats(treatment, var) for var in variables)\n", "\n", "# Convert the dictionary to a DataFrame\n", "control_df = DataFrame(\n", " Variable = collect(keys(control_stats)),\n", " Count = [val[1] for val in values(control_stats)],\n", " Mean = [val[2] for val in values(control_stats)],\n", " Std = [val[3] for val in values(control_stats)]\n", ")\n", "treatment_df = DataFrame(\n", " Variable = collect(keys(treatment_stats)),\n", " Count = [val[1] for val in values(treatment_stats)],\n", " Mean = [val[2] for val in values(treatment_stats)],\n", " Std = [val[3] for val in values(treatment_stats)]\n", ")\n", "control_df = sort!(control_df, :Variable)\n", "treatment_df = sort!(treatment_df, :Variable)\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Table 1: Descriptive Statistics and Balance\n", "\n", "\u001b[1m13×7 DataFrame\u001b[0m\n", "\u001b[1m Row \u001b[0m│\u001b[1m Variable \u001b[0m\u001b[1m Control_Count \u001b[0m\u001b[1m Control_Mean \u001b[0m\u001b[1m Control_Std \u001b[0m\u001b[1m Treatment_Count \u001b[0m\u001b[1m Treatment_Mean \u001b[0m\u001b[1m Treatment_Std \u001b[0m\n", " │\u001b[90m Symbol \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", "─────┼────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", " 1 │ age 818.0 23.05 3.59 921.0 23.16 3.54\n", " 2 │ ethnicgrp_asian 45.0 0.06 0.23 66.0 0.07 0.26\n", " 3 │ ethnicgrp_black 76.0 0.09 0.29 74.0 0.08 0.27\n", " 4 │ ethnicgrp_mixed_multiple 76.0 0.09 0.29 78.0 0.08 0.28\n", " 5 │ ethnicgrp_other 14.0 0.02 0.13 9.0 0.01 0.1\n", " 6 │ ethnicgrp_white 607.0 0.74 0.44 694.0 0.75 0.43\n", " 7 │ gender_female 475.0 0.58 0.49 541.0 0.59 0.49\n", " 8 │ gender_male 342.0 0.42 0.49 377.0 0.41 0.49\n", " 9 │ gender_transgender 1.0 0.0 0.03 3.0 0.0 0.06\n", " 10 │ imd_decile 37.0 3.48 1.49 36.0 3.46 1.47\n", " 11 │ msm 113.0 0.14 0.35 114.0 0.12 0.33\n", " 12 │ partners1 239.0 0.29 0.46 277.0 0.3 0.46\n", " 13 │ postlaunch 387.0 0.47 0.5 512.0 0.56 0.5" ] } ], "source": [ "# Combine control_df and treatment_df into a single DataFrame\n", "combined_df = DataFrame(\n", " Variable = control_df.Variable,\n", " Control_Count = control_df.Count,\n", " Control_Mean = control_df.Mean,\n", " Control_Std = control_df.Std,\n", " Treatment_Count = treatment_df.Count,\n", " Treatment_Mean = treatment_df.Mean,\n", " Treatment_Std = treatment_df.Std\n", ")\n", "\n", "# Round numerical columns to 2 decimal places\n", "function round_df(df::DataFrame, decimals::Int)\n", " rounded_df = copy(df)\n", " for col in names(df)[2:end]\n", " rounded_df[!, col] = round.(df[!, col], digits=decimals)\n", " end\n", " return rounded_df\n", "end\n", "\n", "formatted_table = round_df(combined_df, 2)\n", "\n", "# Print the formatted table\n", "println(\"Table 1: Descriptive Statistics and Balance\\n\")\n", "show(stdout, \"text/plain\", formatted_table)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The observations for each variable are generally balanced between the control and treatment groups. Additionally, most participants are white, with an average age of approximately 23. The mean IMD decile scores are around 3.5, indicating that participants in both groups tend to come from more deprived areas." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
4×4 DataFrame
Rowwgender_malecountprop
Int64Int64Int64Float64
1004760.273721
2013420.196665
3105440.312823
4113770.216791
" ], "text/latex": [ "\\begin{tabular}{r|cccc}\n", "\t& w & gender\\_male & count & prop\\\\\n", "\t\\hline\n", "\t& Int64 & Int64 & Int64 & Float64\\\\\n", "\t\\hline\n", "\t1 & 0 & 0 & 476 & 0.273721 \\\\\n", "\t2 & 0 & 1 & 342 & 0.196665 \\\\\n", "\t3 & 1 & 0 & 544 & 0.312823 \\\\\n", "\t4 & 1 & 1 & 377 & 0.216791 \\\\\n", "\\end{tabular}\n" ], "text/plain": [ "\u001b[1m4×4 DataFrame\u001b[0m\n", "\u001b[1m Row \u001b[0m│\u001b[1m w \u001b[0m\u001b[1m gender_male \u001b[0m\u001b[1m count \u001b[0m\u001b[1m prop \u001b[0m\n", " │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", "─────┼─────────────────────────────────────\n", " 1 │ 0 0 476 0.273721\n", " 2 │ 0 1 342 0.196665\n", " 3 │ 1 0 544 0.312823\n", " 4 │ 1 1 377 0.216791" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "using DataFrames\n", "using StatsPlots\n", "\n", "# Group by 'w' and 'gender_male' and count occurrences\n", "df_grouped = combine(groupby(df, [:w, :gender_male]), nrow => :count)\n", "\n", "# Calculate the proportion of each group\n", "df_grouped[!, :prop] .= df_grouped.count ./ sum(df_grouped.count)\n", "\n", "df_grouped\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "using DataFrames\n", "using Plots\n", "\n", "# Extracting the data\n", "w = df_grouped.w\n", "gender_male = df_grouped.gender_male\n", "prop = df_grouped.prop\n", "\n", "# Creating a grouped bar plot\n", "groupedbar(\n", " string.(gender_male),\n", " prop,\n", " group = string.(w),\n", " xlabel = \"Gender Male (0 = Female, 1 = Male)\",\n", " ylabel = \"Proportion\",\n", " title = \"Grouped Bar Graph of Proportion by w and Gender\",\n", " legend = :topright,\n", " bar_width = 0.5,\n", " label = [\"Treatment = 0\" \"Treatment = 1\"]\n", ")\n", "\n", "# Display the plot\n", "plot!(current())\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "using DataFrames\n", "using StatsPlots\n", "\n", "# Group by 'w' and 'partners1' and count occurrences\n", "df_grouped = combine(groupby(df, [:w, :partners1]), nrow => :count)\n", "\n", "# Calculate the proportion of each group\n", "df_grouped[!, :prop] .= df_grouped.count ./ sum(df_grouped.count)\n", "\n", "# Extracting the data\n", "w = df_grouped.w\n", "partners1 = df_grouped.partners1\n", "prop = df_grouped.prop\n", "\n", "# Creating a grouped bar plot\n", "groupedbar(\n", " string.(partners1),\n", " prop,\n", " group = string.(w),\n", " xlabel = \"Number of partners (one partner=1)\",\n", " ylabel = \"Proportion\",\n", " title = \"Proportion of Partners by Treatment Group\",\n", " legend = :topright,\n", " bar_width = 0.5,\n", " label = [\"Treatment = 0\" \"Treatment = 1\"]\n", ")\n", "\n", "# Display the plot\n", "plot!(current())\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "using DataFrames\n", "using StatsPlots\n", "\n", "# Create density plots for each group in 'w'\n", "density(\n", " df.age,\n", " group = df.w,\n", " xlabel = \"Age\",\n", " ylabel = \"Percentage\",\n", " title = \"Density Plot of Age by Treatment Group\",\n", " legend = :topright,\n", " normalize = true,\n", " label = [\"Control\" \"Treatment\"]\n", ")\n", "\n", "# Display the plot\n", "plot!(current())\n" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "using DataFrames\n", "using StatsPlots\n", "\n", "# Group by 'imd_decile' and 'w' and count occurrences\n", "df_grouped = combine(groupby(df, [:imd_decile, :w]), nrow => :count)\n", "\n", "# Calculate the proportion of each group within 'imd_decile'\n", "df_grouped[!, :prop] .= df_grouped.count ./ sum(df_grouped.count) * 100 # Convert to percentage\n", "\n", "# Create a density-like bar plot\n", "@df df_grouped groupedbar(\n", " :imd_decile,\n", " :prop,\n", " group = :w,\n", " xlabel = \"IMD Decile\",\n", " ylabel = \"Percentage\",\n", " title = \"Density Plot of IMD Decile by Treatment Group\",\n", " legend = :topright,\n", " bar_width = 0.8,\n", " label = [\"Control\" \"Treatment\"]\n", ")\n", "\n", "# Display the plot\n", "plot!(current())\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", "\n", "y ~ 1 + w\n", "\n", "Coefficients:\n", "────────────────────────────────────────────────────────────────────────\n", " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", "────────────────────────────────────────────────────────────────────────\n", "(Intercept) 0.211491 0.0160531 13.17 <1e-37 0.180006 0.242977\n", "w 0.265164 0.0220586 12.02 <1e-31 0.2219 0.308429\n", "────────────────────────────────────────────────────────────────────────" ] } ], "source": [ "using DataFrames\n", "using StatsModels\n", "using GLM\n", "\n", "model_1 = @formula(y ~ w)\n", "est_1 = lm(model_1, df)\n", "\n", "print(est_1)\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", "\n", "y ~ 1 + w + age + gender_female + ethnicgrp_white + ethnicgrp_black + ethnicgrp_mixed_multiple + partners1 + postlaunch + imd_decile\n", "\n", "Coefficients:\n", "───────────────────────────────────────────────────────────────────────────────────────────\n", " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", "───────────────────────────────────────────────────────────────────────────────────────────\n", "(Intercept) -0.163972 0.0880134 -1.86 0.0626 -0.336596 0.00865184\n", "w 0.255827 0.0217719 11.75 <1e-29 0.213125 0.298529\n", "age 0.0124373 0.00316801 3.93 <1e-04 0.0062238 0.0186509\n", "gender_female 0.0928923 0.0223094 4.16 <1e-04 0.0491361 0.136649\n", "ethnicgrp_white 0.0498876 0.0411584 1.21 0.2256 -0.0308379 0.130613\n", "ethnicgrp_black -0.0397451 0.0541118 -0.73 0.4627 -0.145877 0.0663863\n", "ethnicgrp_mixed_multiple -0.035726 0.0534103 -0.67 0.5037 -0.140481 0.0690296\n", "partners1 -0.0590884 0.0242699 -2.43 0.0150 -0.10669 -0.0114868\n", "postlaunch 0.0770255 0.0225539 3.42 0.0007 0.0327897 0.121261\n", "imd_decile -0.00410827 0.0074161 -0.55 0.5797 -0.0186537 0.0104372\n", "───────────────────────────────────────────────────────────────────────────────────────────" ] } ], "source": [ "model_2 = @formula(y ~ w + age + gender_female + ethnicgrp_white + ethnicgrp_black + ethnicgrp_mixed_multiple + partners1 + postlaunch + imd_decile)\n", "est_2 = lm(model_2, df)\n", "\n", "print(est_2)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3. Non-Linear Methods DML" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "using Pkg\n", "Pkg.add(\"DataFrames\")\n", "Pkg.add(\"CSV\")\n", "Pkg.add(\"Statistics\")\n", "Pkg.add(\"StatsModels\")\n", "Pkg.add(\"GLM\")\n", "Pkg.add(\"MLJ\")\n", "Pkg.add(\"XGBoost\")\n", "Pkg.add(\"MLJXGBoostInterface\")\n", "Pkg.add(\"MLJGLMInterface\")\n", "Pkg.add(\"Lasso\")\n", "Pkg.add(\"GLMNet\")\n", "Pkg.add(\"CovarianceMatrices\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m CSV\n", "\u001b[32m ✓ \u001b[39mCSV\n", " 1 dependency successfully precompiled in 9 seconds. 26 already precompiled.\n", "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m StatsModels\n", "\u001b[33m ? \u001b[39m\u001b[90mStatsFuns\u001b[39m\n", "\u001b[36m\u001b[1m Info\u001b[22m\u001b[39m Given StatsModels was explicitly requested, output will be shown live \u001b[0K\n", "\u001b[0KWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\n", "\u001b[0KERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n", "\u001b[33m ? \u001b[39mStatsModels\n", "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling StatsModels [3eaba693-59b7-5ba5-a881-562e759f1c8d]\n", "WARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\n", "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n", "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mSkipping precompilation since __precompile__(false). Importing StatsModels [3eaba693-59b7-5ba5-a881-562e759f1c8d].\n", "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m StatsFuns\n", "\u001b[36m\u001b[1m Info\u001b[22m\u001b[39m Given StatsFuns was explicitly requested, output will be shown live \u001b[0K\n", "\u001b[0KWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\n", "\u001b[0KERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n", "\u001b[33m ? \u001b[39m\u001b[90mStatsFuns\u001b[39m\n", "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling StatsFuns [4c63d2b9-4356-54db-8cca-17b64c39e42c]\n", "WARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\n", "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n", "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mSkipping precompilation since __precompile__(false). Importing StatsFuns [4c63d2b9-4356-54db-8cca-17b64c39e42c].\n", "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m GLM\n", "\u001b[33m ? \u001b[39m\u001b[90mStatsFuns\u001b[39m\n", "\u001b[33m ? \u001b[39m\u001b[90mDistributions\u001b[39m\n", "\u001b[33m ? \u001b[39mStatsModels\n", "\u001b[36m\u001b[1m Info\u001b[22m\u001b[39m Given GLM was explicitly requested, output will be shown live \u001b[0K\n", "\u001b[0KWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\n", "\u001b[0KERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n", "\u001b[33m ? \u001b[39mGLM\n", "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling GLM [38e38edf-8417-5370-95a0-9cbb8c7f171a]\n", "\u001b[33m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[33m\u001b[1mWarning: \u001b[22m\u001b[39mModule StatsFuns with build ID ffffffff-ffff-ffff-0001-616a4687cd8a is missing from the cache.\n", "\u001b[33m\u001b[1m│ \u001b[22m\u001b[39mThis may mean StatsFuns [4c63d2b9-4356-54db-8cca-17b64c39e42c] does not support precompilation but is imported by a module that does.\n", "\u001b[33m\u001b[1m└ \u001b[22m\u001b[39m\u001b[90m@ Base loading.jl:1948\u001b[39m\n", "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mSkipping precompilation since __precompile__(false). Importing GLM [38e38edf-8417-5370-95a0-9cbb8c7f171a].\n", "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m Distributions\n", "\u001b[33m ? \u001b[39m\u001b[90mStatsFuns\u001b[39m\n", "\u001b[36m\u001b[1m Info\u001b[22m\u001b[39m Given Distributions was explicitly requested, output will be shown live \u001b[0K\n", "\u001b[0KWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\n", "\u001b[0KERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n", "\u001b[33m ? \u001b[39m\u001b[90mDistributions\u001b[39m\n", "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling Distributions [31c24e10-a181-5473-b8eb-7969acd0382f]\n", "\u001b[33m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[33m\u001b[1mWarning: \u001b[22m\u001b[39mModule StatsFuns with build ID ffffffff-ffff-ffff-0001-616a4687cd8a is missing from the cache.\n", "\u001b[33m\u001b[1m│ \u001b[22m\u001b[39mThis may mean StatsFuns [4c63d2b9-4356-54db-8cca-17b64c39e42c] does not support precompilation but is imported by a module that does.\n", "\u001b[33m\u001b[1m└ \u001b[22m\u001b[39m\u001b[90m@ Base loading.jl:1948\u001b[39m\n", "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mSkipping precompilation since __precompile__(false). Importing Distributions [31c24e10-a181-5473-b8eb-7969acd0382f].\n" ] } ], "source": [ "using DataFrames\n", "using CSV\n", "using Statistics\n", "using StatsModels\n", "using GLM\n", "using Random\n", "using StatsBase\n", "using LinearAlgebra\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "First few rows of y:\n", "[0; 0; 0; 0; 1;;]\n", "First few rows of d:\n", "[1; 1; 0; 1; 1;;]\n", "First few rows of x:\n", "[1 0 0 0 0 0 0 1 1 0 0 25 6; 0 1 0 0 0 0 0 1 0 0 1 28 5; 1 0 0 0 0 0 0 1 1 1 0 17 6; 1 0 0 0 0 0 0 1 0 1 0 25 2; 1 0 0 0 0 0 0 1 0 0 0 23 2]\n" ] } ], "source": [ "\n", "# Load the CSV file into a DataFrame\n", "file_path = \"C:\\\\Users\\\\juanl\\\\OneDrive\\\\Desktop\\\\hg\\\\data\\\\processed_esti.csv\"\n", "DML = CSV.read(file_path, DataFrame)\n", "\n", "Random.seed!(1234)\n", "\n", "# Split the data into training and testing sets\n", "n = nrow(DML)\n", "training = sample(1:n, round(Int, 0.75 * n), replace=false)\n", "data_train = DML[training, :]\n", "data_test = DML[setdiff(1:n, training), :]\n", "\n", "# Extract the test outcome\n", "Y_test = data_test.y\n", "\n", "# Extract matrices for outcome, treatment, and controls\n", "y = reshape(data_train[:, 1], :, 1) # outcome: growth rate\n", "d = reshape(data_train[:, 2], :, 1) # treatment: initial wealth\n", "x = Matrix(data_train[:, Not([1, 2])]) # controls: country characteristics\n", "\n", "# Display the first few rows to verify\n", "println(\"First few rows of y:\")\n", "println(y[1:5, :])\n", "println(\"First few rows of d:\")\n", "println(d[1:5, :])\n", "println(\"First few rows of x:\")\n", "println(x[1:5, :])\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ScikitLearnBase ─ v0.5.0\n", "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m DecisionTree ──── v0.12.4\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `C:\\Users\\juanl\\.julia\\environments\\v1.10\\Project.toml`\n", " \u001b[90m[7806a523] \u001b[39m\u001b[92m+ DecisionTree v0.12.4\u001b[39m\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `C:\\Users\\juanl\\.julia\\environments\\v1.10\\Manifest.toml`\n", " \u001b[90m[7806a523] \u001b[39m\u001b[92m+ DecisionTree v0.12.4\u001b[39m\n", " \u001b[90m[6e75b9c4] \u001b[39m\u001b[92m+ ScikitLearnBase v0.5.0\u001b[39m\n", "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", "\u001b[33m ? \u001b[39m\u001b[90mStatsFuns\u001b[39m\n", "\u001b[32m ✓ \u001b[39m\u001b[90mScikitLearnBase\u001b[39m\n", "\u001b[32m ✓ \u001b[39m\u001b[90mColorVectorSpace → SpecialFunctionsExt\u001b[39m\n", "\u001b[91m ✗ \u001b[39m\u001b[90mPyCall\u001b[39m\n", "\u001b[91m ✗ \u001b[39m\u001b[90mBinaryProvider\u001b[39m\n", "\u001b[32m ✓ \u001b[39m\u001b[90mLatexify → DataFramesExt\u001b[39m\n", "\u001b[91m ✗ \u001b[39mMLJXGBoostInterface\n", "\u001b[32m ✓ \u001b[39mDecisionTree\n", "\u001b[91m ✗ \u001b[39m\u001b[90mSnappy\u001b[39m\n", "\u001b[33m ? \u001b[39mStatsModels\n", "\u001b[33m ? \u001b[39m\u001b[90mDistributions\u001b[39m\n", "\u001b[91m ✗ \u001b[39m\u001b[90mExcelReaders\u001b[39m\n", "\u001b[91m ✗ \u001b[39m\u001b[90mParquet\u001b[39m\n", "\u001b[33m ? \u001b[39mGLM\n", "\u001b[33m ? \u001b[39mCovarianceMatrices\n", "\u001b[91m ✗ \u001b[39m\u001b[90mExcelFiles\u001b[39m\n", "\u001b[33m ? \u001b[39mGLMNet\n", "\u001b[91m ✗ \u001b[39m\u001b[90mParquetFiles\u001b[39m\n", "\u001b[33m ? \u001b[39mMLJGLMInterface\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJBase\u001b[39m\n", "\u001b[33m ? \u001b[39mLasso\n", "\u001b[91m ✗ \u001b[39mQueryverse\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJIteration\u001b[39m\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJModels\u001b[39m\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJTuning\u001b[39m\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJSerialization\u001b[39m\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJEnsembles\u001b[39m\n", "\u001b[33m ? \u001b[39mMLJ\n", " 4 dependencies successfully precompiled in 42 seconds. 284 already precompiled.\n", " \u001b[33m12\u001b[39m dependencies precompiled but different versions are currently loaded. Restart julia to access the new versions\n", " \u001b[33m15\u001b[39m dependencies failed but may be precompilable after restarting julia\n", " \u001b[33m15\u001b[39m dependencies had output during precompilation:\u001b[33m\n", "┌ \u001b[39mStatsFuns\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mGLMNet\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mMLJ\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mMLJIteration\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mMLJGLMInterface\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mCovarianceMatrices\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mLasso\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mStatsModels\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mMLJTuning\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mMLJBase\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mMLJModels\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mMLJEnsembles\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mGLM\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mMLJSerialization\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\u001b[33m\n", "┌ \u001b[39mDistributions\u001b[33m\n", "│ \u001b[39mWARNING: Method definition (::Type{Base.MPFR.BigFloat})(Base.Irrational{:twoπ}) in module IrrationalConstants at irrationals.jl:223 overwritten in module StatsFuns on the same line (check for duplicate calls to `include`).\u001b[33m\n", "│ \u001b[39mERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\u001b[33m\n", "└ \u001b[39m\n", " \u001b[91m9\u001b[39m dependencies errored.\n", " For a report of the errors see `julia> err`. To retry use `pkg> precompile`\n" ] } ], "source": [ "using Pkg\n", "Pkg.add(\"DecisionTree\")\n", "\n", "using DecisionTree\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### DML function for Regression tree" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "DML2_for_PLM_tree (generic function with 1 method)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "using DecisionTree\n", "using Statistics\n", "\n", "function DML2_for_PLM_tree(data_train, dreg, yreg; nfold=10)\n", " nobs = nrow(data_train) # number of observations\n", " foldid = repeat(1:nfold, ceil(Int, nobs/nfold))[shuffle(1:nobs)] # define fold indices\n", " I = [findall(foldid .== i) for i in 1:nfold] # split observation indices into folds\n", " ytil = fill(NaN, nobs)\n", " dtil = fill(NaN, nobs)\n", " println(\"fold: \")\n", "\n", " for b in 1:nfold\n", " # Exclude the current fold for training\n", " datitanow = data_train[setdiff(1:nobs, I[b]), Not(:d)]\n", " datitanoy = data_train[setdiff(1:nobs, I[b]), Not(:y)]\n", " # Current fold for prediction\n", " datitanowpredict = data_train[I[b], Not(:d)]\n", " datitanoypredict = data_train[I[b], Not(:y)]\n", "\n", " # Fit models\n", " dfit = dreg(datitanoy)\n", " yfit = yreg(datitanow)\n", " # Make predictions\n", " dhat = predict(dfit, DataFrame(datitanoypredict, :auto))\n", " yhat = predict(yfit, DataFrame(datitanowpredict, :auto))\n", " # Record residuals\n", " dtil[I[b]] .= data_train[I[b], :d] .- dhat\n", " ytil[I[b]] .= data_train[I[b], :y] .- yhat\n", " print(\"$b \")\n", " end\n", "\n", " # Ensure ytil and dtil are column vectors\n", " ytil = reshape(ytil, :, 1)\n", " dtil = reshape(dtil, :, 1)\n", "\n", " # Regress one residual on the other\n", " rfit = lm(@formula(ytil ~ dtil), DataFrame(hcat(ytil, dtil), :auto))\n", " coef_est = coef(rfit)[2]\n", " se = sqrt(vcov(HC0, rfit)[2, 2])\n", " println(\"\\ncoef (se) = $coef_est ($se)\")\n", "\n", " return (coef_est = coef_est, se = se, dtil = dtil, ytil = ytil)\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### DML function for Boosting Trees" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "DML2_for_PLM_boosttree (generic function with 1 method)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "using MLJ\n", "using XGBoost\n", "\n", "function DML2_for_PLM_boosttree(data_train, dreg, yreg; nfold=10)\n", " nobs = nrow(data_train) # number of observations\n", " foldid = repeat(1:nfold, ceil(Int, nobs/nfold))[shuffle(1:nobs)] # define fold indices\n", " I = [findall(foldid .== i) for i in 1:nfold] # split observation indices into folds\n", " ytil = fill(NaN, nobs)\n", " dtil = fill(NaN, nobs)\n", " println(\"fold: \")\n", "\n", " for b in 1:nfold\n", " # Exclude the current fold for training\n", " datitanow = data_train[setdiff(1:nobs, I[b]), Not(:d)]\n", " datitanoy = data_train[setdiff(1:nobs, I[b]), Not(:y)]\n", " # Current fold for prediction\n", " datitanowpredict = data_train[I[b], Not(:d)]\n", " datitanoypredict = data_train[I[b], Not(:y)]\n", "\n", " # Fit models\n", " dfit = dreg(datitanoy)\n", " best_boostt = fit!(dfit, verbosity=0) # fit the model\n", " yfit = yreg(datitanow)\n", " best_boosty = fit!(yfit, verbosity=0) # fit the model\n", "\n", " # Make predictions\n", " dhat = MLJ.predict(best_boostt, DataFrame(datitanoypredict, :auto))\n", " yhat = MLJ.predict(best_boosty, DataFrame(datitanowpredict, :auto))\n", "\n", " # Record residuals\n", " dtil[I[b]] .= data_train[I[b], :d] .- dhat\n", " ytil[I[b]] .= data_train[I[b], :y] .- yhat\n", " print(\"$b \")\n", " end\n", "\n", " # Ensure ytil and dtil are column vectors\n", " ytil = reshape(ytil, :, 1)\n", " dtil = reshape(dtil, :, 1)\n", "\n", " # Regress one residual on the other\n", " rfit = lm(@formula(ytil ~ dtil), DataFrame(hcat(ytil, dtil), :auto))\n", " coef_est = coef(rfit)[2]\n", " se = sqrt(vcov(HC0, rfit)[2, 2])\n", " println(\"\\ncoef (se) = $coef_est ($se)\")\n", "\n", " return (coef_est = coef_est, se = se, dtil = dtil, ytil = ytil)\n", "end\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### DML function for Lasso" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "DML2_for_PLM (generic function with 1 method)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "\n", "using DataFrames\n", "using CSV\n", "using GLM\n", "using Random\n", "using StatsBase\n", "using GLMNet\n", "using Statistics\n", "\n", "function DML2_for_PLM(x, d, y, dreg, yreg; nfold=10)\n", " nobs = size(x, 1) # number of observations\n", " foldid = repeat(1:nfold, ceil(Int, nobs/nfold))[shuffle(1:nobs)] # define fold indices\n", " I = [findall(foldid .== i) for i in 1:nfold] # split observation indices into folds\n", " ytil = fill(NaN, nobs)\n", " dtil = fill(NaN, nobs)\n", " println(\"fold: \")\n", "\n", " for b in 1:nfold\n", " # Exclude the current fold for training\n", " train_indices = setdiff(1:nobs, I[b])\n", " test_indices = I[b]\n", "\n", " # Fit models\n", " dfit = dreg(x[train_indices, :], d[train_indices])\n", " yfit = yreg(x[train_indices, :], y[train_indices])\n", "\n", " # Make predictions\n", " dhat = GLMNet.predict(dfit, x[test_indices, :])\n", " yhat = GLMNet.predict(yfit, x[test_indices, :])\n", "\n", " # Record residuals\n", " dtil[test_indices] .= d[test_indices] .- dhat\n", " ytil[test_indices] .= y[test_indices] .- yhat\n", " print(\"$b \")\n", " end\n", "\n", " # Ensure ytil and dtil are column vectors\n", " ytil = vec(ytil)\n", " dtil = vec(dtil)\n", "\n", " # Regress one residual on the other\n", " data = DataFrame(ytil = ytil, dtil = dtil)\n", " rfit = lm(@formula(ytil ~ dtil), data)\n", " coef_est = coef(rfit)[2]\n", " se = sqrt(vcov(HC0, rfit)[2, 2])\n", " println(\"\\ncoef (se) = $coef_est ($se)\")\n", "\n", " return Dict(\"coef.est\" => coef_est, \"se\" => se, \"dtil\" => dtil, \"ytil\" => ytil)\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.1. Lasso" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "fold: \n", "1 2 3 4 5 6 7 8 9 10 " ] }, { "ename": "LoadError", "evalue": "UndefVarError: `coef` not defined", "output_type": "error", "traceback": [ "UndefVarError: `coef` not defined\n", "\n", "Stacktrace:\n", " [1] DML2_for_PLM(x::Matrix{Float64}, d::Vector{Float64}, y::Vector{Float64}, dreg::var\"#18#19\", yreg::var\"#20#21\"; nfold::Int64)\n", " @ Main .\\In[8]:43\n", " [2] top-level scope\n", " @ In[9]:8" ] } ], "source": [ "\n", "\n", "# Define Lasso regression functions\n", "dreg_lasso = (x, d) -> GLMNet.glmnet(x, d, alpha=1.0, lambda=[0.1])\n", "yreg_lasso = (x, y) -> GLMNet.glmnet(x, y, alpha=1.0, lambda=[0.1])\n", "\n", "# Apply DML with Lasso\n", "DML2_lasso = DML2_for_PLM(x, d, y, dreg_lasso, yreg_lasso, nfold=10)\n", "\n", "# Extract results\n", "coef_lasso = DML2_lasso[\"coef.est\"]\n", "se_lasso = DML2_lasso[\"se\"]\n", "prRes_lassoD = mean((DML2_lasso[\"dtil\"]).^2)\n", "prRes_lassoY = mean((DML2_lasso[\"ytil\"]).^2)\n", "\n", "# Format results\n", "prRes_lasso = DataFrame(\n", " Estimate = coef_lasso,\n", " `Standard Error` = se_lasso,\n", " `RMSE D` = sqrt(prRes_lassoD),\n", " `RMSE Y` = sqrt(prRes_lassoY)\n", ")\n", "\n", "# Display the results\n", "println(prRes_lasso)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The message treatment providing information about Internet-accessed sexually transmitted\n", "infection testing predicts an increase in the probability that a person will get tested\n", "by 25.13 percentage points compared to receiving information about nearby clinics offering\n", "in-person testing.\n", "By providing both groups with information about testing, we mitigate the potential reminder\n", "effect, as both groups are equally prompted to consider testing. This approach allows us to\n", "isolate the impact of the type of information \"Internet-accessed testing\" versus \"in-person clinic\n", "testing\" on the likelihood of getting tested. Through randomized assignment, we establish causality\n", "rather than mere correlation, confirming that the intervention's effect is driven by the unique\n", "advantages of Internet-accessed testing, such as increased privacy, reduced embarrassment, and\n", "convenience" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.2. Regression Trees" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "ename": "LoadError", "evalue": "LoadError: ArgumentError: interpolation with $ not supported in @formula. Use @eval @formula(...) instead.\nin expression starting at In[23]:4", "output_type": "error", "traceback": [ "LoadError: ArgumentError: interpolation with $ not supported in @formula. Use @eval @formula(...) instead.\n", "in expression starting at In[23]:4\n", "\n", "Stacktrace:\n", " [1] catch_dollar\n", " @ C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:20 [inlined]\n", " [2] parse!(ex::Expr, rewrites::Vector{DataType})\n", " @ StatsModels C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:180\n", " [3] parse!(ex::Expr, rewrites::Vector{DataType})\n", " @ StatsModels C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:197\n", " [4] parse!(x::Expr)\n", " @ StatsModels C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:176\n", " [5] var\"@formula\"(__source__::LineNumberNode, __module__::Module, ex::Any)\n", " @ StatsModels C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:63" ] } ], "source": [ "\n", "# Set up the basic formula for the regression tree\n", "X_basic = \"gender_transgender + ethnicgrp_asian + ethnicgrp_black + ethnicgrp_mixed_multiple+ ethnicgrp_other + ethnicgrp_white + partners1 + postlaunch + msm + age+ imd_decile\"\n", "y_form_tree = @formula(y ~ $(Meta.parse(X_basic)))\n", "t_form_tree = @formula(w ~ $(Meta.parse(X_basic)))\n", "\n", "# Define tree regression functions\n", "yreg_tree = (dataa) -> DecisionTreeRegressor(min_samples_leaf=5, max_depth=5).fit(Matrix(dataa[:, Not(:y)]), Vector(dataa[:, :y]))\n", "treg_tree = (dataa) -> DecisionTreeRegressor(min_samples_leaf=5, max_depth=5).fit(Matrix(dataa[:, Not(:w)]), Vector(dataa[:, :w]))\n", "\n", "# Apply DML with regression tree\n", "DML2_tree = DML2_for_PLM_tree(data_train, treg_tree, yreg_tree, nfold=10)\n", "\n", "# Extract results\n", "coef_tree = DML2_tree[1]\n", "se_tree = DML2_tree[2]\n", "prRes_treeD = mean((DML2_tree[3]).^2)\n", "prRes_treeY = mean((DML2_tree[4]).^2)\n", "\n", "# Format results\n", "prRes_tree = DataFrame(\n", " Estimate = coef_tree,\n", " `Standard Error` = se_tree,\n", " `RMSE D` = sqrt(prRes_treeD),\n", " `RMSE Y` = sqrt(prRes_treeY)\n", ")\n", "\n", "# Display the results\n", "println(prRes_tree)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The message treatment providing information about Internet-accessed sexually transmitted\n", "infection testing predicts an increase in the probability that a person will get tested\n", "by 23.08 percentage points compared to receiving information about nearby clinics offering\n", "in-person testing.\n", "By providing both groups with information about testing, we mitigate the potential reminder\n", "effect, as both groups are equally prompted to consider testing. This approach allows us to\n", "isolate the impact of the type of information \"Internet-accessed testing\" versus \"in-person clinic\n", "testing\" on the likelihood of getting tested. Through randomized assignment, we establish causality\n", "rather than mere correlation, confirming that the intervention's effect is driven by the unique\n", "advantages of Internet-accessed testing, such as increased privacy, reduced embarrassment, and\n", "convenience" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.3. Boosting Trees" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "ename": "LoadError", "evalue": "LoadError: ArgumentError: interpolation with $ not supported in @formula. Use @eval @formula(...) instead.\nin expression starting at In[25]:3", "output_type": "error", "traceback": [ "LoadError: ArgumentError: interpolation with $ not supported in @formula. Use @eval @formula(...) instead.\n", "in expression starting at In[25]:3\n", "\n", "Stacktrace:\n", " [1] catch_dollar\n", " @ C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:20 [inlined]\n", " [2] parse!(ex::Expr, rewrites::Vector{DataType})\n", " @ StatsModels C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:180\n", " [3] parse!(ex::Expr, rewrites::Vector{DataType})\n", " @ StatsModels C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:197\n", " [4] parse!(x::Expr)\n", " @ StatsModels C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:176\n", " [5] var\"@formula\"(__source__::LineNumberNode, __module__::Module, ex::Any)\n", " @ StatsModels C:\\Users\\juanl\\.julia\\packages\\StatsModels\\fK0P3\\src\\formula.jl:63" ] } ], "source": [ "# Set up the basic formula for the boosted tree\n", "X_basic = \"gender_transgender + ethnicgrp_asian + ethnicgrp_black + ethnicgrp_mixed_multiple+ ethnicgrp_other + ethnicgrp_white + partners1 + postlaunch + msm + age+ imd_decile\"\n", "y_form_tree = @formula(y ~ $(Meta.parse(X_basic)))\n", "t_form_tree = @formula(w ~ $(Meta.parse(X_basic)))\n", "\n", "# Define boosted tree regression functions\n", "yreg_treeboost = (dataa) -> machine(XGBoostRegressor(max_depth=2, nrounds=1000, eta=0.01, subsample=0.5), dataa[:, Not(:y)], dataa[:, :y])\n", "treg_treeboost = (dataa) -> machine(XGBoostRegressor(max_depth=2, nrounds=1000, eta=0.01, subsample=0.5), dataa[:, Not(:w)], dataa[:, :w])\n", "\n", "# Apply DML with boosted trees\n", "DML2_boosttree = DML2_for_PLM_boosttree(data_train, treg_treeboost, yreg_treeboost, nfold=10)\n", "\n", "# Extract results\n", "coef_boosttree = DML2_boosttree[1]\n", "se_boosttree = DML2_boosttree[2]\n", "prRes_boosttreeD = mean((DML2_boosttree[3]).^2)\n", "prRes_boosttreeY = mean((DML2_boosttree[4]).^2)\n", "\n", "# Format results\n", "prRes_boosttree = DataFrame(\n", " Estimate = coef_boosttree,\n", " `Standard Error` = se_boosttree,\n", " `RMSE D` = sqrt(prRes_boosttreeD),\n", " `RMSE Y` = sqrt(prRes_boosttreeY)\n", ")\n", "\n", "# Display the results\n", "println(prRes_boosttree)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The message treatment providing information about Internet-accessed sexually transmitted\n", "infection testing predicts an increase in the probability that a person will get tested\n", "by 25.28 percentage points compared to receiving information about nearby clinics offering\n", "in-person testing.\n", "By providing both groups with information about testing, we mitigate the potential reminder\n", "effect, as both groups are equally prompted to consider testing. This approach allows us to\n", "isolate the impact of the type of information \"Internet-accessed testing\" versus \"in-person clinic\n", "testing\" on the likelihood of getting tested. Through randomized assignment, we establish causality\n", "rather than mere correlation, confirming that the intervention's effect is driven by the unique\n", "advantages of Internet-accessed testing, such as increased privacy, reduced embarrassment, and\n", "convenience" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.4. Random Forest" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "DML2_for_PLM_RF (generic function with 1 method)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Function for Double Machine Learning with Partially Linear Model using Random Forest\n", "function DML2_for_PLM_RF(data_train, dreg, yreg; nfold=10)\n", " nobs = nrow(data_train) # number of observations\n", " foldid = repeat(1:nfold, ceil(Int, nobs/nfold))[shuffle(1:nobs)] # define fold indices\n", " I = [findall(foldid .== i) for i in 1:nfold] # split observation indices into folds\n", " ytil = fill(NaN, nobs)\n", " dtil = fill(NaN, nobs)\n", " println(\"fold: \")\n", "\n", " for b in 1:nfold\n", " # Exclude the current fold for training\n", " train_indices = setdiff(1:nobs, I[b])\n", " test_indices = I[b]\n", "\n", " # Fit models\n", " dfit = dreg(x[train_indices, :], d[train_indices])\n", " yfit = yreg(x[train_indices, :], y[train_indices])\n", "\n", " # Make predictions\n", " dhat = predict(dfit, x[test_indices, :])\n", " yhat = predict(yfit, x[test_indices, :])\n", "\n", " # Record residuals\n", " dtil[test_indices] .= d[test_indices] .- dhat\n", " ytil[test_indices] .= y[test_indices] .- yhat\n", " print(\"$b \")\n", " end\n", "\n", " # Ensure ytil and dtil are column vectors\n", " ytil = vec(ytil)\n", " dtil = vec(dtil)\n", "\n", " # Regress one residual on the other\n", " data = DataFrame(ytil = ytil, dtil = dtil)\n", " rfit = lm(@formula(ytil ~ dtil), data)\n", " coef_est = coef(rfit)[2]\n", " se = sqrt(vcov(HC0, rfit)[2, 2])\n", " println(\"\\ncoef (se) = $coef_est ($se)\")\n", "\n", " return Dict(\"coef.est\" => coef_est, \"se\" => se, \"dtil\" => dtil, \"ytil\" => ytil)\n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "ename": "LoadError", "evalue": "MethodError: no method matching DML2_for_PLM_RF(::Matrix{Float64}, ::Vector{Float64}, ::Vector{Float64}, ::var\"#55#56\", ::var\"#57#58\"; nfold::Int64)\n\n\u001b[0mClosest candidates are:\n\u001b[0m DML2_for_PLM_RF(::Any, ::Any, ::Any; nfold)\n\u001b[0m\u001b[90m @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[26]:2\u001b[24m\u001b[39m\n", "output_type": "error", "traceback": [ "MethodError: no method matching DML2_for_PLM_RF(::Matrix{Float64}, ::Vector{Float64}, ::Vector{Float64}, ::var\"#55#56\", ::var\"#57#58\"; nfold::Int64)\n", "\n", "\u001b[0mClosest candidates are:\n", "\u001b[0m DML2_for_PLM_RF(::Any, ::Any, ::Any; nfold)\n", "\u001b[0m\u001b[90m @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[26]:2\u001b[24m\u001b[39m\n", "\n", "\n", "Stacktrace:\n", " [1] top-level scope\n", " @ In[27]:7" ] } ], "source": [ "\n", "# Define Random Forest regression functions\n", "dreg_RF = (x, d) -> RandomForestRegressor(n_trees=100).fit(x, d)\n", "yreg_RF = (x, y) -> RandomForestRegressor(n_trees=100).fit(x, y)\n", "\n", "# Apply DML with Random Forest\n", "DML2_RF = DML2_for_PLM_RF(x, d, y, dreg_RF, yreg_RF, nfold=10)\n", "\n", "# Extract results\n", "coef_RF = DML2_RF[\"coef.est\"]\n", "se_RF = DML2_RF[\"se\"]\n", "prRes_RFD = mean((DML2_RF[\"dtil\"]).^2)\n", "prRes_RFY = mean((DML2_RF[\"ytil\"]).^2)\n", "\n", "# Format results\n", "prRes_RF = DataFrame(\n", " Estimate = coef_RF,\n", " `Standard Error` = se_RF,\n", " `RMSE D` = sqrt(prRes_RFD),\n", " `RMSE Y` = sqrt(prRes_RFY)\n", ")\n", "\n", "# Display the results\n", "println(prRes_RF)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The message treatment providing information about Internet-accessed sexually transmitted\n", "infection testing predicts an increase in the probability that a person will get tested\n", "by 24.14 percentage points compared to receiving information about nearby clinics offering\n", "in-person testing.\n", "By providing both groups with information about testing, we mitigate the potential reminder\n", "effect, as both groups are equally prompted to consider testing. This approach allows us to\n", "isolate the impact of the type of information \"Internet-accessed testing\" versus \"in-person clinic\n", "testing\" on the likelihood of getting tested. Through randomized assignment, we establish causality\n", "rather than mere correlation, confirming that the intervention's effect is driven by the unique\n", "advantages of Internet-accessed testing, such as increased privacy, reduced embarrassment, and\n", "convenience" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.5. Table and Coefficient plot" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Table" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Coefficient Plot" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: `DML2_lasso` not defined", "output_type": "error", "traceback": [ "UndefVarError: `DML2_lasso` not defined\n", "\n", "Stacktrace:\n", " [1] top-level scope\n", " @ In[28]:2" ] } ], "source": [ "prRes_D = [\n", " mean((DML2_lasso[\"dtil\"]).^2),\n", " mean((DML2_tree[\"dtil\"]).^2),\n", " mean((DML2_boosttree[\"dtil\"]).^2),\n", " mean((DML2_RF[\"dtil\"]).^2)\n", "]\n", "\n", "prRes_Y = [\n", " mean((DML2_lasso[\"ytil\"]).^2),\n", " mean((DML2_tree[\"ytil\"]).^2),\n", " mean((DML2_boosttree[\"ytil\"]).^2),\n", " mean((DML2_RF[\"ytil\"]).^2)\n", "]\n", "\n", "prRes = hcat(sqrt.(prRes_D), sqrt.(prRes_Y))\n", "rownames!(prRes, [\"RMSE D\", \"RMSE Y\"])\n", "colnames!(prRes, [\"Lasso\", \"Reg Tree\", \"Boost Tree\", \"Random Forest\"])\n", "\n", "# Create results table\n", "table = zeros(4, 4)\n", "\n", "# Point Estimate\n", "table[1, 1] = DML2_lasso[\"coef.est\"]\n", "table[2, 1] = DML2_tree[\"coef.est\"]\n", "table[3, 1] = DML2_boosttree[\"coef.est\"]\n", "table[4, 1] = DML2_RF[\"coef.est\"]\n", "\n", "# SE\n", "table[1, 2] = DML2_lasso[\"se\"]\n", "table[2, 2] = DML2_tree[\"se\"]\n", "table[3, 2] = DML2_boosttree[\"se\"]\n", "table[4, 2] = DML2_RF[\"se\"]\n", "\n", "# RMSE Y\n", "table[1, 3] = prRes[2, 1]\n", "table[2, 3] = prRes[2, 2]\n", "table[3, 3] = prRes[2, 3]\n", "table[4, 3] = prRes[2, 4]\n", "\n", "# RMSE D\n", "table[1, 4] = prRes[1, 1]\n", "table[2, 4] = prRes[1, 2]\n", "table[3, 4] = prRes[1, 3]\n", "table[4, 4] = prRes[1, 4]\n", "\n", "# Print results\n", "colnames!(table, [\"Estimate\", \"Standard Error\", \"RMSE Y\", \"RMSE D\"])\n", "rownames!(table, [\"Lasso\", \"Reg Tree\", \"Boost Tree\", \"Random Forest\"])\n", "\n", "# Display the table\n", "println(table)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `C:\\Users\\juanl\\.julia\\environments\\v1.10\\Project.toml`\n", "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `C:\\Users\\juanl\\.julia\\environments\\v1.10\\Manifest.toml`\n", "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", "\u001b[33m ? \u001b[39m\u001b[90mStatsFuns\u001b[39m\n", "\u001b[33m ? \u001b[39mStatsModels\n", "\u001b[33m ? \u001b[39m\u001b[90mDistributions\u001b[39m\n", "\u001b[33m ? \u001b[39mGLM\n", "\u001b[33m ? \u001b[39mCovarianceMatrices\n", "\u001b[33m ? \u001b[39mGLMNet\n", "\u001b[33m ? \u001b[39mMLJGLMInterface\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJBase\u001b[39m\n", "\u001b[33m ? \u001b[39mLasso\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJIteration\u001b[39m\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJTuning\u001b[39m\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJEnsembles\u001b[39m\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJSerialization\u001b[39m\n", "\u001b[33m ? \u001b[39m\u001b[90mMLJModels\u001b[39m\n", "\u001b[33m ? \u001b[39mMLJ\n" ] }, { "ename": "LoadError", "evalue": "ArgumentError: Package plots not found in current path.\n- Run `import Pkg; Pkg.add(\"plots\")` to install the plots package.", "output_type": "error", "traceback": [ "ArgumentError: Package plots not found in current path.\n", "- Run `import Pkg; Pkg.add(\"plots\")` to install the plots package.\n", "\n", "Stacktrace:\n", " [1] macro expansion\n", " @ .\\loading.jl:1772 [inlined]\n", " [2] macro expansion\n", " @ .\\lock.jl:267 [inlined]\n", " [3] __require(into::Module, mod::Symbol)\n", " @ Base .\\loading.jl:1753\n", " [4] #invoke_in_world#3\n", " @ .\\essentials.jl:926 [inlined]\n", " [5] invoke_in_world\n", " @ .\\essentials.jl:923 [inlined]\n", " [6] require(into::Module, mod::Symbol)\n", " @ Base .\\loading.jl:1746" ] } ], "source": [ "using Pkg\n", "Pkg.add(\"Plots\")\n", "using plots" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "ename": "LoadError", "evalue": "MethodError: no method matching DataFrame(::typeof(table), ::Vector{String})\n\n\u001b[0mClosest candidates are:\n\u001b[0m DataFrame(\u001b[91m::AbstractVector{<:Type}\u001b[39m, ::AbstractVector{<:AbstractString}, \u001b[91m::Integer\u001b[39m; makeunique)\n\u001b[0m\u001b[90m @\u001b[39m \u001b[36mDataFrames\u001b[39m \u001b[90mC:\\Users\\juanl\\.julia\\packages\\DataFrames\\JZ7x5\\src\\dataframe\\\u001b[39m\u001b[90m\u001b[4mdataframe.jl:397\u001b[24m\u001b[39m\n\u001b[0m DataFrame(\u001b[91m::AbstractVector{<:AbstractVector}\u001b[39m, ::AbstractVector; makeunique, copycols)\n\u001b[0m\u001b[90m @\u001b[39m \u001b[36mDataFrames\u001b[39m \u001b[90mC:\\Users\\juanl\\.julia\\packages\\DataFrames\\JZ7x5\\src\\dataframe\\\u001b[39m\u001b[90m\u001b[4mdataframe.jl:344\u001b[24m\u001b[39m\n\u001b[0m DataFrame(\u001b[91m::AbstractVector{<:Type}\u001b[39m, ::AbstractVector{<:AbstractString}; ...)\n\u001b[0m\u001b[90m @\u001b[39m \u001b[36mDataFrames\u001b[39m \u001b[90mC:\\Users\\juanl\\.julia\\packages\\DataFrames\\JZ7x5\\src\\dataframe\\\u001b[39m\u001b[90m\u001b[4mdataframe.jl:397\u001b[24m\u001b[39m\n\u001b[0m ...\n", "output_type": "error", "traceback": [ "MethodError: no method matching DataFrame(::typeof(table), ::Vector{String})\n", "\n", "\u001b[0mClosest candidates are:\n", "\u001b[0m DataFrame(\u001b[91m::AbstractVector{<:Type}\u001b[39m, ::AbstractVector{<:AbstractString}, \u001b[91m::Integer\u001b[39m; makeunique)\n", "\u001b[0m\u001b[90m @\u001b[39m \u001b[36mDataFrames\u001b[39m \u001b[90mC:\\Users\\juanl\\.julia\\packages\\DataFrames\\JZ7x5\\src\\dataframe\\\u001b[39m\u001b[90m\u001b[4mdataframe.jl:397\u001b[24m\u001b[39m\n", "\u001b[0m DataFrame(\u001b[91m::AbstractVector{<:AbstractVector}\u001b[39m, ::AbstractVector; makeunique, copycols)\n", "\u001b[0m\u001b[90m @\u001b[39m \u001b[36mDataFrames\u001b[39m \u001b[90mC:\\Users\\juanl\\.julia\\packages\\DataFrames\\JZ7x5\\src\\dataframe\\\u001b[39m\u001b[90m\u001b[4mdataframe.jl:344\u001b[24m\u001b[39m\n", "\u001b[0m DataFrame(\u001b[91m::AbstractVector{<:Type}\u001b[39m, ::AbstractVector{<:AbstractString}; ...)\n", "\u001b[0m\u001b[90m @\u001b[39m \u001b[36mDataFrames\u001b[39m \u001b[90mC:\\Users\\juanl\\.julia\\packages\\DataFrames\\JZ7x5\\src\\dataframe\\\u001b[39m\u001b[90m\u001b[4mdataframe.jl:397\u001b[24m\u001b[39m\n", "\u001b[0m ...\n", "\n", "\n", "Stacktrace:\n", " [1] top-level scope\n", " @ In[37]:2" ] } ], "source": [ "# Convert `table` to DataFrame\n", "table_ci = DataFrame(table, [\"Estimate\", \"Standard Error\", \"RMSE Y\", \"RMSE D\"])\n", "table_ci.Method = [\"Lasso\", \"Reg Tree\", \"Boost Tree\", \"Random Forest\"]\n", "\n", "# Calculate confidence intervals\n", "table_ci.CI_Lower_1 = table_ci.Estimate .- 2.576 .* table_ci.\"Standard Error\"\n", "table_ci.CI_Upper_1 = table_ci.Estimate .+ 2.576 .* table_ci.\"Standard Error\"\n", "table_ci.CI_Lower_5 = table_ci.Estimate .- 1.96 .* table_ci.\"Standard Error\"\n", "table_ci.CI_Upper_5 = table_ci.Estimate .+ 1.96 .* table_ci.\"Standard Error\"\n", "table_ci.CI_Lower_10 = table_ci.Estimate .- 1.645 .* table_ci.\"Standard Error\"\n", "table_ci.CI_Upper_10 = table_ci.Estimate .+ 1.645 .* table_ci.\"Standard Error\"\n", "\n", "# Plotting\n", "plot(table_ci.Method, table_ci.Estimate, seriestype=:scatter, label=\"Estimate\", markersize=4)\n", "plot!(table_ci.Method, table_ci.CI_Lower_5, ribbon=(table_ci.CI_Upper_5 .- table_ci.CI_Lower_5), label=\"95% CI\", lw=2, lc=:blue, alpha=0.7)\n", "plot!(table_ci.Method, table_ci.CI_Lower_10, ribbon=(table_ci.CI_Upper_10 .- table_ci.CI_Lower_10), label=\"90% CI\", lw=2, lc=:red, alpha=0.7)\n", "plot!(table_ci.Method, table_ci.CI_Lower_1, ribbon=(table_ci.CI_Upper_1 .- table_ci.CI_Lower_1), label=\"99% CI\", lw=2, lc=:green, alpha=0.7)\n", "title!(\"Estimated Coefficients with Confidence Intervals\")\n", "xlabel!(\"Method\")\n", "ylabel!(\"Estimate\")\n", "theme(:minimal)\n", "xticks!(1:4, table_ci.Method)\n", "xrotation!(45)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.6. Model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To choose the best model, we must compare the RMSEs of the outcome variable Y. In this case, the model with the lowest RMSE for Y\n", "is generated by Lasso (0.4716420), whereas the lowest for the treatment is generated by Boosting Trees (0.4983734). Therefore, DML\n", "could be employed with Y cleaned using Lasso and the treatment using Boosting Trees." ] } ], "metadata": { "kernelspec": { "display_name": "Julia 1.10.2", "language": "julia", "name": "julia-1.10" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.10.2" } }, "nbformat": 4, "nbformat_minor": 2 }