Simulation

package.json

@@ -26,7 +26,9 @@
         "prettier:check": "prettier --check ./src",
         "prettier:fix": "prettier --write ./src",
         "test": "export stage=DEV; jest",
-        "riffraff": "node-riffraff-artifact"
+        "riffraff": "node-riffraff-artifact",
+        "simulate": "stage=DEV ts-node src/simulation/simulation.ts",
+        "with-real-data": "stage=PROD ts-node src/simulation/withRealData.ts"
     },
     "devDependencies": {
         "@babel/core": "^7.23.2",
@@ -64,6 +66,7 @@
         "rollup-plugin-terser": "^7.0.2",
         "ts-jest": "^29.4.5",
         "ts-loader": "^9.2.5",
+        "ts-node": "^10.9.2",
         "ts-node-dev": "^2.0.0",
         "tslib": "^2.5.3",
         "typescript": "~5.5.2",
@@ -74,6 +77,7 @@
         "zod": "4.3.5"
     },
     "dependencies": {
+        "@types/gaussian": "^1.2.2",
         "@aws-sdk/client-cloudwatch": "^3.835.0",
         "@aws-sdk/client-dynamodb": "^3.835.0",
         "@aws-sdk/client-s3": "^3.835.0",
@@ -87,6 +91,7 @@
         "cors": "^2.8.5",
         "date-fns": "^2.25.0",
         "express": "^4.21.2",
+        "gaussian": "^1.3.0",
         "jsonschema": "^1.4.0",
         "lodash.debounce": "^4.0.8",
         "lodash.throttle": "^4.1.1",

src/server/selection/banditData.ts

@@ -25,7 +25,7 @@ const variantSampleSchema = z.object({
     views: z.number(),
 });
 
-type VariantSample = z.infer<typeof variantSampleSchema>;
+export type VariantSample = z.infer<typeof variantSampleSchema>;
 
 const testSampleSchema = z.object({
     testName: z.string(),
@@ -36,7 +36,7 @@ const testSampleSchema = z.object({
 
 const queryResultSchema = z.array(testSampleSchema);
 
-type TestSample = z.infer<typeof testSampleSchema>;
+export type TestSample = z.infer<typeof testSampleSchema>;
 
 interface BanditTestConfig {
     testName: string; // this may be specific to the methodology, e.g. MY_TEST_EpsilonGreedyBandit-0.5
@@ -61,7 +61,7 @@ function queryForTestSamples(testName: string, channel: Channel, sampleCount?: n
     );
 }
 
-async function getBanditSamplesForTest(
+export async function getBanditSamplesForTest(
     testName: string,
     channel: Channel,
     sampleCount?: number,
@@ -118,7 +118,7 @@ function calculateMeanPerVariant(
     });
 }
 
-function calculateOverallMeanForVariant(samples: VariantSample[]): number {
+export function calculateOverallMeanForVariant(samples: VariantSample[]): number {
     const population = samples.reduce((acc, sample) => acc + sample.views, 0);
     return samples.reduce(
         (acc, sample) => acc + (sample.views / population) * sample.annualisedValueInGBPPerView,

src/simulation/models.ts

@@ -0,0 +1,25 @@
+import type { BanditData } from '../server/selection/banditData';
+import type { Test, Variant } from '../shared/types';
+
+export interface SelectionAlgorithm {
+    name: string;
+    run: <V extends Variant, T extends Test<V>>(
+        test: T,
+        testBanditData?: BanditData,
+    ) => V | undefined;
+}
+
+export interface VariantModel {
+    name: string;
+    // TODO - make total timesteps available
+    mean: (timestep: number, totalTimesteps: number) => number;
+    standardDeviation: (timestep: number) => number;
+}
+
+export interface Simulation {
+    algorithms: SelectionAlgorithm[];
+    variantsScenario: VariantModel[];
+    timesteps: number;
+    impressionsPerTimestep: number;
+    runs: number;
+}

src/simulation/oracle.ts

@@ -0,0 +1,10 @@
+import gaussian from "gaussian";
+import type {VariantModel} from "./models";
+
+// An "oracle" that returns the current score for a variant at the given timestep by sampling a normal distribution
+// TODO - return mean as well
+export const sample = (variantModel: VariantModel, timestep: number, totalTimesteps: number): number => {
+    const mean = variantModel.mean(timestep, totalTimesteps);
+    const sd = variantModel.standardDeviation(timestep);
+    return gaussian(mean, sd * sd).ppf(Math.random());
+}

src/simulation/simulation.ts

@@ -0,0 +1,159 @@
+import * as fs from 'fs';
+import type {
+    BanditData,
+    VariantSample
+} from '../server/selection/banditData';
+import {
+    calculateOverallMeanForVariant
+} from '../server/selection/banditData';
+import { selectVariantUsingEpsilonGreedy } from '../server/selection/epsilonGreedySelection';
+import { selectVariantUsingRoulette } from '../server/selection/rouletteSelection';
+import type { Test, Variant } from '../shared/types';
+import type { Simulation } from './models';
+import {sample} from "./oracle";
+import { selectRandomVariant } from '../server/selection/helpers';
+
+const outputFilePath = './simulation_results.csv';
+
+
+const run = (simulation: Simulation) => {
+    // TODO - output cumulative AV
+    /**
+     * - cumulativeSampledMean, based on all samples so far
+     * - impressions - for this timestep
+     * - averageValueInGBPPerView - average sampled value for this timestep
+     * - totalValueInGBP - total £ value for this timestep
+     * - cumulativeValueInGBP - total £ value over all previous timesteps
+     */
+    fs.writeFileSync(outputFilePath, 'algorithm,run,timestep,variant,cumulativeSampledMean,impressions,averageValueInGBPPerView,totalValueInGBP,cumulativeValueInGBP\n', 'utf8');
+
+    const test: Test<Variant> = {
+        channel: 'Epic',
+        name: 'simulated-test',
+        status: 'Live',
+        priority: 1,
+        variants: simulation.variantsScenario.map(v => ({name: v.name})),
+    };
+
+    for (const algorithm of simulation.algorithms) {
+        // initialise variant means to 0 at the start of the "test"
+        const samples: Record<string, VariantSample[]> = {};
+        const cumulativeValueInGBP: Record<string, number> = {};
+        for (const variant of simulation.variantsScenario) {
+            samples[variant.name] = [];
+            cumulativeValueInGBP[variant.name] = 0;
+        }
+
+        for (let run = 0; run < simulation.runs; run++) {
+            for (let timestep = 0; timestep < simulation.timesteps; timestep++) {
+                // Calculate the means for each variant using all of the samples so far
+                const banditData: BanditData = {
+                    testName: test.name,
+                    sortedVariants: [],
+                };
+                for (const variant of test.variants) {
+                    const mean = calculateOverallMeanForVariant(samples[variant.name]);
+                    banditData.sortedVariants.push({
+                        variantName: variant.name,
+                        mean,
+                    });
+                }
+                banditData.sortedVariants = banditData.sortedVariants.sort((a, b) => b.mean - a.mean);
+
+                // initialise impression counts for each variant to 0
+                const variantImpressions: Record<string,number> = test.variants.reduce((acc, v) => (
+                    {
+                        ...acc,
+                        [v.name]: 0,
+                    }
+                ), {});
+                // assign impressions to variants using the algorithm
+                for (
+                    let impression = 0;
+                    impression < simulation.impressionsPerTimestep;
+                    impression++
+                ) {
+                    // pick a variant for this impression
+                    if (timestep < 6) {
+                        // random selection in the discovery period
+                        const variant = selectRandomVariant(test);
+                        if (variant) {
+                            variantImpressions[variant.name]++;
+                        }
+                    } else {
+                        const variant = algorithm.run(test, banditData);
+                        if (variant) {
+                            variantImpressions[variant.name]++;
+                        }
+                    }
+                }
+                console.log({timestep, algo: algorithm.name})
+                console.log({variantImpressions})
+                // update banditData by sampling using each variantModel
+                for (const variant of simulation.variantsScenario) {
+                    let sum = 0;
+                    for (let batch = 0; batch < variantImpressions[variant.name]; batch++) {
+                        const value = sample(variant, timestep, simulation.timesteps);
+                        sum += value;
+                    }
+                    const meanValue = sum / variantImpressions[variant.name];
+                    console.log({name: variant.name, meanValue})
+
+                    const variantSample: VariantSample = {
+                        variantName: variant.name,
+                        views: variantImpressions[variant.name],
+                        annualisedValueInGBP: meanValue * variantImpressions[variant.name],
+                        annualisedValueInGBPPerView: meanValue,
+                    };
+                    samples[variant.name].push(variantSample);
+
+                    cumulativeValueInGBP[variant.name] += variantSample.annualisedValueInGBP;
+
+                    const cumulativeSampledMean = banditData.sortedVariants.find(v => v.variantName === variant.name)?.mean;
+                    const row = `${algorithm.name},${run},${timestep},${variant.name},${cumulativeSampledMean},${variantSample.views},${variantSample.annualisedValueInGBPPerView},${variantSample.annualisedValueInGBP},${cumulativeValueInGBP[variant.name]}\n`;
+                    fs.appendFileSync(outputFilePath, row, 'utf8');
+                }
+            }
+        }
+    }
+};
+
+// TODO - load the config from somewhere
+run({
+    algorithms: [
+        {
+            name: 'roulette',
+            run: selectVariantUsingRoulette,
+        },
+        {
+            name: 'epsilon-greedy-1',
+            run: (test, testBanditData) =>
+                selectVariantUsingEpsilonGreedy(test, 1, testBanditData),
+        },
+        {
+            name: 'epsilon-greedy-0.5',
+            run: (test, testBanditData) =>
+                selectVariantUsingEpsilonGreedy(test, 0.5, testBanditData),
+        },
+    ],
+    variantsScenario: [
+        {
+            name: 'v1',
+            mean: () => 25,
+            standardDeviation: (timestep) => 0.1,
+        },
+        {
+            name: 'v2',
+            mean: (timestep, totalTimesteps) => (100 * (timestep+1)) / totalTimesteps,
+            standardDeviation: (timestep) => 0.1,
+        },
+        {
+            name: 'v3',
+            mean: (timestep) => Math.sin((timestep)/32)*100,
+            standardDeviation: (timestep) => 0.1,
+        },
+    ],
+    timesteps: 100,
+    impressionsPerTimestep: 100,
+    runs: 1,
+});