Skip to content

Main content

Bayesian Rule List Demonstrator Source Code

Browse the implementation files for Bayesian Rule List Demonstrator.
tool.ts typescript
// Tool: Bayesian Rule List Demonstrator

interface Rule {
	conditions: Record<string, boolean | number | string>;
	failures: number;
	name: string;
	successes: number;
}

const parsePositive = (input: unknown): number | null => {
	const value =
		typeof input === 'string' || typeof input === 'number'
			? Number(input)
			: NaN;
	return Number.isFinite(value) && value > 0 ? value : null;
};

const parseCount = (input: unknown): number | null => {
	const value =
		typeof input === 'string' || typeof input === 'number'
			? Number(input)
			: NaN;
	return Number.isSafeInteger(value) && value >= 0
		? value
		: null;
};

const parseJson = (input: unknown): unknown => {
	if (typeof input !== 'string' || input.trim() === '')
		return null;
	try {
		return JSON.parse(input);
	} catch {
		return null;
	}
};

export const demonstrateBayesianRuleList = (
	rulesInput: unknown,
	recordsInput: unknown,
	priorAlphaInput: unknown,
	priorBetaInput: unknown,
	defaultSuccessesInput: unknown,
	defaultFailuresInput: unknown
): string => {
	const rulesValue = parseJson(rulesInput);
	const recordsValue = parseJson(recordsInput);
	const priorAlpha = parsePositive(priorAlphaInput);
	const priorBeta = parsePositive(priorBetaInput);
	const defaultSuccesses = parseCount(defaultSuccessesInput);
	const defaultFailures = parseCount(defaultFailuresInput);

	if (
		!Array.isArray(rulesValue) ||
		rulesValue.length === 0 ||
		rulesValue.length > 100 ||
		!Array.isArray(recordsValue) ||
		recordsValue.length === 0 ||
		recordsValue.length > 1_000 ||
		priorAlpha === null ||
		priorBeta === null ||
		defaultSuccesses === null ||
		defaultFailures === null
	) {
		return '';
	}

	const rules: Rule[] = [];
	for (const value of rulesValue) {
		if (
			typeof value !== 'object' ||
			value === null ||
			typeof value.name !== 'string' ||
			value.name.trim() === '' ||
			typeof value.conditions !== 'object' ||
			value.conditions === null ||
			Array.isArray(value.conditions)
		) {
			return '';
		}
		const entries = Object.entries(value.conditions);
		const successes = parseCount(value.successes);
		const failures = parseCount(value.failures);
		if (
			entries.length === 0 ||
			entries.some(
				([, condition]) =>
					!['boolean', 'number', 'string'].includes(
						typeof condition
					)
			) ||
			successes === null ||
			failures === null
		) {
			return '';
		}
		rules.push({
			conditions: value.conditions,
			failures,
			name: value.name,
			successes
		});
	}

	if (
		!recordsValue.every(
			(record) =>
				typeof record === 'object' &&
				record !== null &&
				!Array.isArray(record)
		)
	) {
		return '';
	}

	const posterior = (
		successes: number,
		failures: number
	): number =>
		(successes + priorAlpha) /
		(successes + failures + priorAlpha + priorBeta);
	const predictions = (
		recordsValue as Record<string, unknown>[]
	).map((record, index) => {
		const matchedIndex = rules.findIndex((rule) =>
			Object.entries(rule.conditions).every(
				([feature, expected]) => record[feature] === expected
			)
		);
		const matched =
			matchedIndex >= 0 ? rules[matchedIndex] : null;
		return {
			index,
			matchedRule: matched?.name ?? 'default',
			probability: Number(
				posterior(
					matched?.successes ?? defaultSuccesses,
					matched?.failures ?? defaultFailures
				).toPrecision(12)
			)
		};
	});

	return JSON.stringify(
		{
			predictions,
			rules: rules.map((rule) => ({
				...rule,
				posteriorProbability: Number(
					posterior(rule.successes, rule.failures).toPrecision(
						12
					)
				)
			}))
		},
		null,
		2
	);
};

const DEFAULT_RULES =
	'[{"name":"senior-smoker","conditions":{"ageGroup":"senior","smoker":true},"successes":8,"failures":2},{"name":"smoker","conditions":{"smoker":true},"successes":6,"failures":4}]';

export const Tool: TypeTool = {
	name: 'Bayesian Rule List Demonstrator',
	slug: 'machine-learning/bayesian-rule-list',
	intro:
		'Apply an ordered probabilistic rule list using beta-binomial posterior predictions.',
	tool: demonstrateBayesianRuleList,
	i: [
		{
			example: DEFAULT_RULES,
			label: 'Rules',
			placeholder: 'JSON ordered rules',
			render: 'textarea',
			type: 'text',
			value: DEFAULT_RULES
		},
		{
			example:
				'[{"ageGroup":"senior","smoker":true},{"ageGroup":"adult","smoker":false}]',
			label: 'Records',
			placeholder: 'JSON records to classify',
			render: 'textarea',
			type: 'text',
			value:
				'[{"ageGroup":"senior","smoker":true},{"ageGroup":"adult","smoker":false}]'
		},
		{
			example: '1',
			label: 'Prior Alpha',
			placeholder: 'Positive beta-prior alpha',
			type: 'number',
			value: 1
		},
		{
			example: '1',
			label: 'Prior Beta',
			placeholder: 'Positive beta-prior beta',
			type: 'number',
			value: 1
		},
		{
			example: '1',
			label: 'Default Successes',
			placeholder: 'Non-negative default successes',
			type: 'number',
			value: 1
		},
		{
			example: '4',
			label: 'Default Failures',
			placeholder: 'Non-negative default failures',
			type: 'number',
			value: 4
		}
	],
	o: [
		{
			example: '{ "predictions": [] }',
			label: 'Predictions',
			placeholder: 'Rule-list predictions will appear here...',
			render: 'textarea',
			type: 'text'
		}
	],
	cite: [
		{
			title: 'Scalable Bayesian Rule Lists',
			url: 'https://proceedings.mlr.press/v70/yang17h.html'
		},
		{
			title: 'Decision list — Wikipedia',
			url: 'https://en.wikipedia.org/wiki/Decision_list'
		}
	]
};

export default Tool;

Description

Browse the implementation files for Bayesian Rule List Demonstrator.

References

  1. Tool.io on GitHub
  2. Tool.io TypeScript tools library

Similar or alternative tools