31:T638,md`# One-step Estimators and Pathwise Derivatives "One-step estimator", "pathwise derivative", and "pathwise differentiable parameter" are terms I was introduced to as I started learning about the statistics of causal inference. In context, you might see a sentence like "pathwise differentiable parameters can be estimated using Targeted Maximum Likelihood Estimation". Unfortunately, googling "pathwise differentiability" returned lists of papers that, while useful I'm sure for people already in the know, aren't geared towards beginners. I am working my way through the math, and a breakthrough came via the excellent recent paper _Visually Communicating and Teaching Intuition for Influence Functions_ [(Fisher & Kennedy 2020)](https://www.tandfonline.com/doi/full/10.1080/00031305.2020.1717620), which helped me build some intuition as to what "pathwise differentiability" really means. This notebook is a brief, non-rigorous summary of some of the ideas in that paper, presented by an example. I've mostly used the same notation so you can go on to read the paper without any confusion. The overall goal of this notebook is to provide some intuition for what a _pathwise derivative_ is, and show how it can be used to form a _one-step estimator_. ### An example Let's start by setting up an example we can use to illustrate one-step estimators. Suppose there is a probability distribution ${tex`\textcolor{${colors.P}}{P}`} (with corresponding density function ${tex`\textcolor{${colors.P}}{p(x)}`}). We'll call this the "true data generating distribution". It looks like this: `32:T809,{ const height = 300 const svg = d3.select(DOM.svg(width, height)); const margin = { top: 20, right: 20, bottom: 40, left: 120 }; const data = domain.map((x) => ({ x: x, y: p(x) })); const x = d3.scaleLinear() .domain([domain[0], domain[domain.length - 1]]) .range([margin.left, width - margin.right]) const y = d3.scaleLinear() .domain([0, d3.max(data.map((d) => d.y))]) .range([height - margin.bottom, margin.top]); const line = d3.line() .x((d) => x(d.x)) .y((d) => y(d.y)); const arrowId = DOM.uid("arrow"); svg.append("defs") .append("marker") .attr("id", arrowId.id) .attr("markerHeight", 10) .attr("markerWidth", 10) .attr("refX", 5) .attr("refY", 2.5) .attr("orient", "auto") .append("path") .attr("fill", "rgba(0, 0, 0, 0.3)") .attr("d", "M0,0v5l7,-2.5Z"); svg.append('foreignObject') .attr('width', 200) .attr('height', 100) .attr('transform', `translate(${x(-1) - 200}, ${y(p(-1)) - 30})`) .style("text-align", "right") .html(tex`\text{true distribution } \textcolor{${colors.P}}{p(x)}`.outerHTML) svg.selectAll('path.density') .data([{ color: colors.P, data: data }]) .enter() .append('path') .attr('class', 'density') .attr('d', (d) => line(d.data)) .attr('stroke', (d) => d.color) .attr('fill', 'transparent') svg.append("g") .attr("class", "axis axis--x") .attr("transform", `translate(${-0.5},${height - margin.bottom})`) .call(d3.axisBottom(x)); svg.append("g") .attr("class", "axis axis--y") .attr("transform", `translate(${margin.left - 10},0)`) .call(d3.axisLeft(y)); svg.append("text") .style("font-style", "italic") .text("x") .attr("transform", `translate(${width/2}, ${height})`); svg.append("text") .style("font-style", "italic") .attr("text-anchor", "end") .text("Density") .attr("transform", `translate(${margin.left - 50}, ${margin.top + 10})`); return svg.node(); }33:T723,md` ### Functional A _functional_ (you could also call it a _parameter_) is any function that takes in a probability distribution and returns a number (or multiple numbers). For example, the mean is a functional: given a probability distribution, you compute ${tex`\mathbb{E}(X) = \int x p(x) dx`} and get back a number. For this example, we'll target a slightly more complicated parameter than the mean, the integral of the squared density: ${tex.block`T(P)=\int p(x)^2 dx`} This parameter doesn't usually have any practical significance, but it's useful as a toy example. Other functionals might be the average treatment effect in causal inference, or the probability of survival after a certain time point in survival analysis. For the true data generating distribution ${tex`P`}, the value of this squared density parameter is ${tex`T(\textcolor{${colors.P}}{P}) = ${d3.format("0.3r")(T_P)}`}. Of course in the real world, we don't know the true data generating distribution; we need to estimate it. Once we have an estimate of the distribution, we can "plug it in" to the formula for the functional to get an estimate for the parameter. To make this more concrete, say we take ${tex`${N}`} samples from the true data generating distribution ${tex`\textcolor{${colors.P}}{P}`}: ${tex.block` X = \left[ ${X.slice(0, 4).map((x) => Math.round(x * 100) / 100)}, \dots \right] `} We can use these data to estimate the data generating distribution. For this example we'll use a kernel density estimator. We call this estimated distribution ${tex`\textcolor{${colors.P_tilde}}{\tilde{P}}`}, with a corresponding density ${tex`\textcolor{${colors.P_tilde}}{\tilde{p}}`}. The plot below shows how the estimated ${tex`\textcolor{${colors.P_tilde}}{\tilde{P}}`} compares to the truth, ${tex`\textcolor{${colors.P}}{P}`}. `34:Tbdd,{ const height = 400 const svg = d3.select(DOM.svg(width, height)); const margin = { top: 100, right: 20, bottom: 40, left: 120 }; const arrowId = DOM.uid("arrow"); svg.append("defs") .append("marker") .attr("id", arrowId.id) .attr("markerHeight", 10) .attr("markerWidth", 10) .attr("refX", 5) .attr("refY", 2.5) .attr("orient", "auto") .append("path") .attr("fill", "rgba(0, 0, 0, 0.3)") .attr("d", "M0,0v5l7,-2.5Z"); const data = [ { color: colors.P, data: domain.map((x) => ({ x: x, y: p(x) })) }, { color: colors.P_tilde, data: kde.map((x) => ({ x: x[0], y: x[1] })) } ]; const x = d3.scaleLinear() .domain([domain[0], domain[domain.length - 1]]) .range([margin.left, width - margin.right]) const y = d3.scaleLinear() .domain([0, d3.max(data.map((d) => d.data).flat().map((d) => d.y))]) .range([height - margin.bottom, margin.top]); const line = d3.line() .x((d) => x(d.x)) .y((d) => y(d.y)); const arrows = [ { x1: 0, x2: 0, y1: p(0), y2: p(0), x1_adj: -20, x2_adj: 0, y1_adj: -20, y2_adj: -5, label_adj_x: -200, label_adj_y: -25, label: tex`\small \text{true distribution } \textcolor{${colors.P}}{p(x)}` }, { x1: -1.5, x2: -1.5, y1: p_tilde(-1.5), y2: p_tilde(-1.5), x1_adj: -20, x2_adj: 0, y1_adj: -20, y2_adj: -5, label_adj_x: -200, label_adj_y: -25, label: tex`\small \text{estimated distribution } \textcolor{${colors.P_tilde}}{\tilde{P}(x)}` } ]; svg.selectAll("path.pointer") .data(arrows) .join("path") .attr("class", "pointer") .attr("d", d => curve_path(d, x, y)) .attr("marker-end", arrowId) .attr('stroke', 'rgba(0, 0, 0, 0.3)') .attr('fill', 'none'); svg.selectAll('foreignObject') .data(arrows) .join('foreignObject') .attr('width', 220) .attr('height', 50) .attr('transform', (d) => `translate(${x(d.x1) + d.x1_adj + d.label_adj_x}, ${y(d.y1) + d.y1_adj + d.label_adj_y})`) .style("text-align", "right") .html((d) => d.label.outerHTML) svg.selectAll('path.density') .data(data) .enter() .append('path') .attr('class', 'density') .attr('d', (d) => line(d.data)) .attr('stroke', (d) => d.color) .attr('fill', 'transparent') svg.append("g") .attr("class", "axis axis--x") .attr("transform", `translate(${-0.5},${height - margin.bottom})`) .call(d3.axisBottom(x)); svg.append("g") .attr("class", "axis axis--y") .attr("transform", `translate(${margin.left - 10},0)`) .call(d3.axisLeft(y)); svg.append("text") .style("font-style", "italic") .text("x") .attr("transform", `translate(${width/2}, ${height})`); svg.append("text") .style("font-style", "italic") .attr("text-anchor", "end") .text("Density") .attr("transform", `translate(${margin.left - 50}, ${margin.top + 10})`); return svg.node(); }35:T65a,md` The estimate of our functional using this estimated distribution is ${tex`T(\textcolor{${colors.P_tilde}}{\tilde{P}}) = ${d3.format("0.3r")(T_P_epsilon)}`} (off by ${d3.format(".1%")(Math.abs(T_P_epsilon - T_P) / T_P)} compared to the true value). Now we do a thought experiment. How would our estimate of the functional change if we could nudge our estimated distribution towards the true distribution? Specifically, we define a family of distributions ${tex`\textcolor{${colors.P_epsilon}}{P_\epsilon}`} which are mixtures of the estimated distribution and the true distribution. The density of ${tex`\textcolor{${colors.P_epsilon}}{p_\epsilon}`} is given by

1. This is just possible one way of defining a family of distributions that mix the true and estimated distributions. However we decide to mix these two distributions, it's important that when ${tex`\epsilon=0`} the mixture distribution is the true distribution, i.e. ${tex`\textcolor{${colors.P_epsilon}}{p_\epsilon} = \textcolor{${colors.P}}{p}`}.

${tex.block` \textcolor{${colors.P_epsilon}}{p_\epsilon} = (1 - \epsilon) \textcolor{${colors.P}}{p} + \epsilon \textcolor{${colors.P_tilde}}{\tilde{p}} `} where ${tex`\epsilon`} is a number between zero and one¹. When ${tex`\epsilon=0`} we get back the true distribution, when ${tex`\epsilon=1`} we get back the estimated distribution, and when ${tex`\epsilon`} is in between we get a mixture of the two. Try changing ${tex`\epsilon`} in the slider below to see how ${tex`\textcolor{${colors.P_epsilon}}{p_\epsilon}`} changes. `36:Td1a,{ const height = 400 const svg = d3.select(DOM.svg(width, height)); const margin = { top: 100, right: 20, bottom: 40, left: 120 }; const data = [ { color: colors.P, data: domain.map((x) => ({ x: x, y: p(x) })) }, { color: colors.P_tilde, data: domain.map((x) => ({ x: x, y: p_tilde(x) })) }, { color: colors.P_epsilon, data: domain.map((x) => ({ x: x, y: p_epsilon(x, epsilon) })) } ]; const arrowId = DOM.uid("arrow"); svg.append("defs") .append("marker") .attr("id", arrowId.id) .attr("markerHeight", 10) .attr("markerWidth", 10) .attr("refX", 5) .attr("refY", 2.5) .attr("orient", "auto") .append("path") .attr("fill", "rgba(0, 0, 0, 0.3)") .attr("d", "M0,0v5l7,-2.5Z"); const x = d3.scaleLinear() .domain([domain[0], domain[domain.length - 1]]) .range([margin.left, width - margin.right]) const y = d3.scaleLinear() .domain([0, d3.max(data.map((d) => d.data).flat().map((d) => d.y))]) .range([height - margin.bottom, margin.top]); const line = d3.line() .x((d) => x(d.x)) .y((d) => y(d.y)); svg.selectAll('path.density') .data(data) .enter() .append('path') .attr('class', 'density') .attr('d', (d) => line(d.data)) .attr('stroke', (d) => d.color) .attr('fill', 'transparent') const arrows = [ { x1: 0, x2: 0, y1: p(0), y2: p(0), x1_adj: -20, x2_adj: 0, y1_adj: -20, y2_adj: -5, label_adj_x: -200, label_adj_y: -25, label: tex`\small \text{true distribution } \textcolor{${colors.P}}{p(x)}` }, { x1: -1.5, x2: -1.5, y1: p_tilde(-1.5), y2: p_tilde(-1.5), x1_adj: -20, x2_adj: 0, y1_adj: -20, y2_adj: -5, label_adj_x: -200, label_adj_y: -25, label: tex`\small \text{estimated distribution } \textcolor{${colors.P_tilde}}{\tilde{p}(x)}` }, { x1: 1, x2: 1, y1: p_epsilon(1, epsilon), y2: p_epsilon(1, epsilon), x1_adj: 20, x2_adj: 0, y1_adj: -20, y2_adj: -5, label_adj_x: -170, label_adj_y: -25, label: tex`\small\textcolor{${colors.P_epsilon}}{p_\epsilon(x)}` } ]; svg.selectAll("path.pointer") .data(arrows) .join("path") .attr("class", "pointer") .attr("d", d => curve_path(d, x, y)) .attr("marker-end", arrowId) .attr('stroke', 'rgba(0, 0, 0, 0.3)') .attr('fill', 'none'); svg.selectAll('foreignObject') .data(arrows) .join('foreignObject') .attr('width', 230) .attr('height', 50) .attr('transform', (d) => `translate(${x(d.x1) + d.x1_adj + d.label_adj_x}, ${y(d.y1) + d.y1_adj + d.label_adj_y})`) .style("text-align", "right") .html((d) => d.label.outerHTML) svg.append("g") .attr("class", "axis axis--x") .attr("transform", `translate(${-0.5},${height - margin.bottom})`) .call(d3.axisBottom(x)); svg.append("g") .attr("class", "axis axis--y") .attr("transform", `translate(${margin.left - 10},0)`) .call(d3.axisLeft(y)); svg.append("text") .style("font-style", "italic") .text("x") .attr("transform", `translate(${width/2}, ${height})`); svg.append("text") .style("font-style", "italic") .attr("text-anchor", "end") .text("Density") .attr("transform", `translate(${margin.left - 50}, ${margin.top + 10})`); return svg.node(); }37:T427,md` ### Pathwise Derivatives A _pathwise derivative_ is the derivative of ${tex`T(\textcolor{${colors.P_epsilon}}{P_\epsilon})`} with respect to ${tex`\epsilon`}. In this case it's useful to think of a derivative as a _direction_: for each value of ${tex`\epsilon`}, the pathwise derivative tells us which direction the functional ${tex`T(\textcolor{${colors.P_epsilon}}{P_\epsilon})`} is moving. Why is this useful? When ${tex`\epsilon=1`}, ${tex`\textcolor{${colors.P_tilde}}{\tilde{P}}`} is the estimated distribution. The pathwise derivative at that point tells us how our estimate of ${tex`T(\textcolor{${colors.P_tilde}}{\tilde{P}})`} would change if we nudged our estimate in the right direction, towards the true distribution. In the example below, the dotted arrow shows the pathwise derivative of the functional at ${tex`\epsilon=1`}. Usually (but not always!) the arrow points in the direction of the truth. Try resampling the data a few times (using the button ealier in the post) to see different examples of how the pathwise derivative behaves. `38:T460,path_plot( [{ epsilon: 0, T: onestep_estimate, color: 'black' }], [{ x1: 0, x2: 0, y1: onestep_estimate, y2: onestep_estimate, x1_adj: -40, x2_adj: -10, y1_adj: 15, y2_adj: 1, label: tex`\text{one-step estimate}`}], (svg, x, y) => { const slope = onestep_estimate - T_P_tilde; const x1 = 1; const x2 = 0.02; const y1 = T_P_tilde; const y2 = T_P_tilde + 0.98 * slope; const arrowId = DOM.uid("arrow"); svg.append("defs") .append("marker") .attr("id", arrowId.id) .attr("markerHeight", 5) .attr("markerWidth", 5) .attr("refX", 5/2) .attr("refY", 5/4) .attr("orient", "auto") .append("path") .attr("fill", "rgba(0, 0, 0, 1)") .attr("d", "M0,0v2.5l3.5,-1.25Z"); svg.append('line') .attr('x1', x(x1)) .attr('x2', x(x2)) .attr('y1', y(y1)) .attr('y2', y(y2)) .attr('stroke', 'black') .attr('stroke-width', 3) .attr('stroke-dasharray', '3 3') .attr("marker-end", arrowId); svg.append('circle') .attr('cx', x(x1)) .attr('cy', y(y1)) .attr('r', 3) .attr('fill', 'black'); })39:Ta68,md` Performing such a linear correction often improves the estimate: in the plot above, the "one-step estimate" will usually be closer to the true value than the initial guess. We should be fair here and note that we've made the one-step estimator somewhat superpowered in this example. This is because the one-step estimate shown above is created using the true value of the pathwise derivative, which is unknown in practice. In any practical setting, we would need to use the observed data to _estimate_ the pathwise derivative. If you resample the data enough times, you will eventually find a dataset for which the one-step estimator gives a negative estimate of the target functional. This isn't a very good estimate since we know our target functional must be positive. One-step estimators don't respect any bounds on the target functional, which can lead to nonsensical results. An alternative family of estimators, Targeted Maximum Likelihood Estimators, provide one way around this problem. ### Pathwise differentiability A functional is called _pathwise differentiable_ if it's possible to compute it's pathwise derivative. This is a desirable property to have because it allows for the creation of one-step estimators, like the one showed above, and other techniques like Targeted Maximum Likelihood Estimation (TMLE). Fortunately, many parameters of real-world interest are pathwise differentiable: for example, the average treatment effect for a binary intervention is a pathwise differentiable parameter. ### Where do we get this derivative? So far I've said nothing about where this pathwise derivative comes from. It turns out it's related to the _influence function_ of the target functional. The term _influence function_ comes from its origins in robust statistics, where it was developed to quantify how much an estimator will change when its input changes (in other words, how much influence each input data point has on the outcome.) In robust statistics, they're mostly concerned with what happens when your data is perturbed in a bad direction, so they can understand how things like outliers will impact an estimator. In our case, we are more interested in how estimators change when our estimates are nudged in the right direction, towards the true data distribution. [Fisher & Kennedy 2020]((https://www.tandfonline.com/doi/full/10.1080/00031305.2020.1717620) goes into much more detail about influence functions, and includes a derivation of the influence function for the target functional used in this example. [Levy 2019](https://arxiv.org/pdf/1903.01706.pdf) has derivations for a number of other target functionals. `3a:T1171,path_plot = (extra_points = [], extra_arrows = [], callback = () => null) => { const height = 350 const width = 600 const svg = d3.select(DOM.svg(width, height)); const margin = { top: 20, right: 20, bottom: 60, left: 240 }; const points = [ { epsilon: 0, T: T(domain, p_tilde), color: colors.P_tilde }, { epsilon: 0, T: T(domain, p), color: colors.P }, { epsilon: 0, T: T_P_epsilon, color: colors.P_epsilon } ].concat(extra_points); const arrows = [ { x1: 0, x2: 0, y1: points[0].T, y2: points[0].T, x1_adj: -100, x2_adj: -10, y1_adj: 30, y2_adj: 1, label: tex`\text{initial guess: }T(\textcolor{${colors.P_tilde}}{\tilde{P}})`}, { x1: 0, x2: 0, y1: points[1].T, y2: points[1].T, x1_adj: -100, x2_adj: -10, y1_adj: 30, y2_adj: 1, label: tex`\text{true value: }T(\textcolor{${colors.P}}{P})`}, { x1: 0, x2: 0, y1: T_P_epsilon, y2: T_P_epsilon, x1_adj: -40, x2_adj: -10, y1_adj: 15, y2_adj: 1, label: tex`T(\textcolor{${colors.P_epsilon}}{P_\epsilon})`} ].concat(extra_arrows); const arrowId = DOM.uid("arrow"); svg.append("defs") .append("marker") .attr("id", arrowId.id) .attr("markerHeight", 10) .attr("markerWidth", 10) .attr("refX", 5) .attr("refY", 2.5) .attr("orient", "auto") .append("path") .attr("fill", "rgba(0, 0, 0, 0.3)") .attr("d", "M0,0v5l7,-2.5Z"); const x = d3.scaleLinear() .domain([0, 1]) .range([margin.left, width - margin.right]) const yExtent = d3.extent(path.map((x) => x.T).concat(points.map((d) => d.T))); const y = d3.scaleLinear() .domain(yExtent) .range([height - margin.bottom, margin.top]); const line = d3.line() .x((d) => x(d.epsilon)) .y((d) => y(d.T)); svg.selectAll('path.epsilon') .data([path]) .enter() .append('path') .attr('class', 'epsilon') .attr('d', (d) => line(d)) .attr('stroke', palette.midnight_blue) .attr('fill', 'transparent') svg.selectAll('circle.epsilon') .data([{ epsilon: epsilon, T: T(domain, (x) => p_epsilon(x, epsilon)) }]) .enter() .append('circle') .attr('class', 'epsilon') .attr('r', 3) .attr('cx', (d) => x(d.epsilon)) .attr('cy', (d) => y(d.T)); svg.selectAll("path.pointer") .data(arrows) .join("path") .attr("class", "pointer") .attr("d", d => { const x1 = x(d.x1) + d.x1_adj; const x2 = x(d.x2) + d.x2_adj; const y1 = y(d.y1) + d.y1_adj; const y2 = y(d.y2) + d.y2_adj; const r = Math.hypot(x1 - x2, y1 - y2) * 2; return ` M${x1},${y1} A${r},${r} 0,0,1 ${x2},${y2} `; }) .attr("marker-end", arrowId) .attr('stroke', 'rgba(0, 0, 0, 0.3)') .attr('fill', 'none'); const objs = svg.selectAll("foreignObject.pointer") .data(arrows) .join("foreignObject") .attr("class", "pointer") .attr("transform", (d) => `translate(${x(d.x1) + d.x1_adj - 120}, ${y(d.y1) + d.y1_adj}) scale(0.8)`) .attr("width", 160) .attr("height", 30) .style("text-align", "right") .style("font-style", "italic") .style("color", "rgba(0, 0, 0, 0.8)") .html((d) => d.label.outerHTML); svg.selectAll("line.initial_guess") .data([ { x1: 0, x2: 1, y1: points[0].T, y2: points[0].T }, { x1: 0, x2: epsilon, y1: T_P_epsilon, y2: T_P_epsilon } ]) .join("line") .attr("class", "initial_guess") .attr("x1", (d) => x(d.x1)) .attr("x2", (d) => x(d.x2)) .attr("y1", (d) => y(d.y1)) .attr("y2", (d) => y(d.y2)) .attr("stroke", "rgba(0, 0, 0, 0.5)") .attr("stroke-dasharray", "2 4") svg.append("g") .attr("class", "axis axis--x") .attr("transform", `translate(${-0.5},${height - margin.bottom})`) .call(d3.axisBottom(x)); svg.append("g") .attr("class", "axis axis--y") .attr("transform", `translate(${margin.left},0)`) .call(d3.axisLeft(y).ticks(3)); svg.selectAll('circle.points') .data(points) .enter() .append('circle') .attr('class', 'epsilon') .attr('r', 3) .attr('cx', (d) => x(d.epsilon)) .attr('cy', (d) => y(d.T)) .attr('fill', (d) => d.color); svg.append("text") .style("font-style", "italic") .text("ε") .attr("transform", `translate(${margin.left + (width - margin.left - margin.right)/2}, ${height})`); callback(svg, x, y, arrowId); return svg.node(); }3b:[] 2f:{"title":"One-step Estimators and Pathwise Derivatives","cells":[{"id":0,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":71,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":94,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":195,"value":"viewof N = slider({ step: 1, min: 5, max: 100, value: 50, title: \"Number of samples\" })","pinned":false,"hidden":false,"mode":"ojs"},{"id":311,"value":"viewof resample = button({ value: \"Resample\" })","pinned":false,"hidden":false,"mode":"ojs"},{"id":177,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":557,"value":"$35","pinned":false,"hidden":false,"mode":"ojs"},{"id":257,"value":"$36","pinned":false,"hidden":false,"mode":"ojs"},{"id":660,"value":"md`\n\nFor every value of ${tex`\\epsilon`} we can compute a corresponding value of the functional: ${tex`T(\\textcolor{${colors.P_epsilon}}{P_\\epsilon})`}. These values trace out a trajectory as they move from the initual guess, ${tex`T(\\textcolor{${colors.P_tilde}}{\\tilde{P}})`}, to the true value, ${tex`T(\\textcolor{${colors.P}}{P})`}. Move the slider below to change ${tex`\\epsilon`}, and see how ${tex`T(\\textcolor{${colors.P_epsilon}}{P_\\epsilon})`} creates a trajectory as it approaches the true value.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":872,"value":"bind(slider({ min: 0, max: 1, title: tex`\\epsilon`}), viewof epsilon)","pinned":false,"hidden":false,"mode":"ojs"},{"id":702,"value":"path_plot(() => null)","pinned":false,"hidden":false,"mode":"ojs"},{"id":671,"value":"$37","pinned":false,"hidden":false,"mode":"ojs"},{"id":706,"value":"path_plot([], [], (svg, x, y) => {\n const slope = mean_with_respect_to_distribution(domain, IF(domain, p_tilde, T), p);\n const x1 = 1;\n const x2 = 1 - 0.3;\n const y1 = T_P_tilde;\n const y2 = T_P_tilde + 0.3 * slope;\n \n const arrowId = DOM.uid(\"arrow\");\n \n svg.append(\"defs\")\n .append(\"marker\")\n .attr(\"id\", arrowId.id)\n .attr(\"markerHeight\", 5)\n .attr(\"markerWidth\", 5)\n .attr(\"refX\", 5/2)\n .attr(\"refY\", 5/4)\n .attr(\"orient\", \"auto\")\n .append(\"path\")\n .attr(\"fill\", \"rgba(0, 0, 0, 1)\")\n .attr(\"d\", \"M0,0v2.5l3.5,-1.25Z\");\n \n svg.append('line')\n .attr('x1', x(x1))\n .attr('x2', x(x2))\n .attr('y1', y(y1))\n .attr('y2', y(y2))\n .attr('stroke', 'black')\n .attr('stroke-width', 3)\n .attr('stroke-dasharray', '3 3')\n .attr(\"marker-end\", arrowId);\n \n svg.append('circle')\n .attr('cx', x(x1))\n .attr('cy', y(y1))\n .attr('r', 3)\n .attr('fill', 'black');\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":876,"value":"bind(slider({ min: 0, max: 1, title: tex`\\epsilon`}), viewof epsilon)","pinned":false,"hidden":false,"mode":"ojs"},{"id":962,"value":"md`\n## One-step Estimator\nWe can use this to form a better estimate of the functional by using this pathwise derivative to approximate the trajectory as a linear function. This is called a \"one-step\" estimator, because it's like performing a single step of Newton's method.\n\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":936,"value":"$38","pinned":false,"hidden":false,"mode":"ojs"},{"id":967,"value":"$39","pinned":false,"hidden":false,"mode":"ojs"},{"id":687,"value":"md`\n\n### Notes\n\n_Further Reading_\n- Visually Communicating and Teaching Intuition for Influence Functions [(Fisher & Kennedy 2020)]((https://www.tandfonline.com/doi/full/10.1080/00031305.2020.1717620)\n- Semiparametric Theory [(Kennedy 2017)](https://arxiv.org/abs/1709.06418)\n- Tutorial: Deriving The Efficient Influence Curve For Large Models [(Levy 2019)](https://arxiv.org/pdf/1903.01706.pdf)\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":277,"value":"$3a","pinned":false,"hidden":false,"mode":"ojs"},{"id":123,"value":"X = { resample; return [...Array(N).keys()].map(rnorm).map((x) => x) }","pinned":false,"hidden":false,"mode":"ojs"},{"id":270,"value":"path = Array(...Array(101).keys()).map((x) => x / 100).map((epsilon) => ({ epsilon: epsilon, T: T(domain, (x) => p_epsilon(x, epsilon)) }))","pinned":false,"hidden":false,"mode":"ojs"},{"id":199,"value":"bandwidth = 1 // 1.06 * Math.sqrt(d3.variance(X)) * Math.pow(N, -1/5)","pinned":false,"hidden":false,"mode":"ojs"},{"id":172,"value":"kernel = kernelEpanechnikov(bandwidth)","pinned":false,"hidden":false,"mode":"ojs"},{"id":174,"value":"kde = kernelDensityEstimator(kernel, domain)(X)","pinned":false,"hidden":false,"mode":"ojs"},{"id":302,"value":"p_tilde = linear_interpolator(kde.map((x) => x[0]), kde.map((x) => x[1]))","pinned":false,"hidden":false,"mode":"ojs"},{"id":793,"value":"viewof epsilon = new View(0.5)","pinned":false,"hidden":false,"mode":"ojs"},{"id":227,"value":"// Assumes sorted x\nlinear_interpolator = (x, y) => {\n return (v) => {\n if(v < x[0]) return y[0];\n if(v >= x[x.length - 1]) return y[x.length - 1];\n for(let i = 1; i < x.length; i++) {\n if(v < x[i]) {\n const n = (v - x[i - 1]) / (x[i] - x[i -1]);\n return (1 - n) * y[i - 1] + n * y[i];\n }\n }\n };\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":146,"value":"T = (x, p) => {\n let value = 0;\n for(let i = 0; i < x.length - 1; i++) {\n const diff = x[i + 1] - x[i];\n value += diff * Math.pow(p(x[i]), 2);\n }\n return value;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":149,"value":"T_P = T(domain, p)","pinned":false,"hidden":false,"mode":"ojs"},{"id":765,"value":"T_P_tilde = T(domain, p_tilde)","pinned":true,"hidden":false,"mode":"ojs"},{"id":399,"value":"T_P_epsilon = T(domain, (x) => p_epsilon(x, epsilon))","pinned":false,"hidden":false,"mode":"ojs"},{"id":951,"value":"onestep_estimate = T_P_tilde + mean_with_respect_to_distribution(domain, IF(domain, p_tilde, T), p)","pinned":false,"hidden":false,"mode":"ojs"},{"id":72,"value":"domain = [...Array(1000).keys()].map((x) => x / 1000 * 7 - 7/2)","pinned":false,"hidden":false,"mode":"ojs"},{"id":725,"value":"IF = (x, p, T) => {\n const T_P = T(x, p);\n return x.map((d) => 2 * (p(d) - T_P));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":733,"value":"mean_with_respect_to_distribution = (x, y, p) => {\n let sum = 0;\n for(let i = 1; i < x.length; i++) {\n sum += (x[i] - x[i - 1]) * y[i] * p(x[i]);\n }\n \n return sum;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":68,"value":"p = (x) => 1 / Math.sqrt(2 * Math.PI) * Math.exp(-Math.pow(x, 2) / 2)","pinned":false,"hidden":false,"mode":"ojs"},{"id":224,"value":"p_epsilon = (x, epsilon) => (1 - epsilon) * p(x) + epsilon * p_tilde(x)","pinned":false,"hidden":false,"mode":"ojs"},{"id":55,"value":"d3 = require('d3')","pinned":false,"hidden":false,"mode":"ojs"},{"id":97,"value":"kernelEpanechnikov = (k) =>\n (v) => Math.abs(v /= k) <= 1 ? 0.75 * (1 - v * v) / k : 0","pinned":false,"hidden":false,"mode":"ojs"},{"id":99,"value":"kernelDensityEstimator = (kernel, X) =>\n (V) =>\n X.map((x) => [x, d3.mean(V, (v) => kernel(x - v))])","pinned":false,"hidden":false,"mode":"ojs"},{"id":109,"value":"// Box-Muller from https://stackoverflow.com/questions/25582882/javascript-math-random-normal-distribution-gaussian-bell-curve\nrnorm = () => {\n let u = 0, v = 0;\n while(u === 0) u = Math.random(); //Converting [0,1) to (0,1)\n while(v === 0) v = Math.random();\n return Math.sqrt( -2.0 * Math.log( u ) ) * Math.cos( 2.0 * Math.PI * v );\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":614,"value":"curve_path = (d, x, y) => {\n const x1 = x(d.x1) + d.x1_adj;\n const x2 = x(d.x2) + d.x2_adj;\n const y1 = y(d.y1) + d.y1_adj;\n const y2 = y(d.y2) + d.y2_adj;\n const r = Math.hypot(x1 - x2, y1 - y2) * 2;\n return `\n M${x1},${y1}\n A${r},${r} 0,0,1 ${x2},${y2}\n `;\n }","pinned":false,"hidden":false,"mode":"ojs"},{"id":515,"value":"colors = ({\n P: palette.belize_hole,\n P_tilde: palette.nephritis,\n P_epsilon: palette.wisteria\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":836,"value":"function bind(form, view) {\n const input = form.getElementsByTagName(\"input\")[0];\n const output = form.getElementsByTagName(\"output\")[0];\n input.value = view.value;\n input.oninput = () => view.value = input.valueAsNumber;\n\n \n function update({value}) {\n if (!isNaN(value) && input.valueAsNumber !== value) {\n input.value = value;\n output.innerHTML = d3.format(\"0.2r\")(view.value);\n }\n }\n\n view.addEventListener(\"input\", update);\n return Generators.disposable(form, () => {\n view.removeEventListener(\"input\", update);\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":80,"value":"import { palette } from \"@herbps10/flat-ui-colors\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":193,"value":"import {slider, button} from \"@jashkenas/inputs\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":791,"value":"import {View} from \"@mbostock/synchronized-views\"","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W3b","stdlib":"1","titling":"auto"}