Skip to content

Main content

Adagrad Optimizer Step Calculator Source Code

Browse the implementation files for Adagrad Optimizer Step Calculator.
tool.ts typescript
// Tool: Adagrad Optimizer Step Calculator

const parseFiniteNumber = (input: unknown): number | null => {
	if (
		(typeof input !== 'string' && typeof input !== 'number') ||
		(typeof input === 'string' && input.trim() === '')
	) {
		return null;
	}

	const value = Number(input);

	return Number.isFinite(value) ? value : null;
};

const round = (value: number): number =>
	Number(value.toPrecision(12));

export const calculateAdagradStep = (
	parameterInput: unknown,
	gradientInput: unknown,
	accumulatedSquaredGradientInput: unknown,
	learningRateInput: unknown,
	epsilonInput: unknown
): string => {
	const parameter = parseFiniteNumber(parameterInput);
	const gradient = parseFiniteNumber(gradientInput);
	const accumulatedSquaredGradient = parseFiniteNumber(
		accumulatedSquaredGradientInput
	);
	const learningRate = parseFiniteNumber(learningRateInput);
	const epsilon = parseFiniteNumber(epsilonInput);

	if (
		parameter === null ||
		gradient === null ||
		accumulatedSquaredGradient === null ||
		learningRate === null ||
		epsilon === null ||
		accumulatedSquaredGradient < 0 ||
		learningRate <= 0 ||
		epsilon <= 0
	) {
		return '';
	}

	const nextAccumulatedSquaredGradient =
		accumulatedSquaredGradient + gradient ** 2;
	const update =
		(learningRate * gradient) /
		(Math.sqrt(nextAccumulatedSquaredGradient) + epsilon);
	const nextParameter = parameter - update;

	if (
		![
			nextAccumulatedSquaredGradient,
			nextParameter,
			update
		].every(Number.isFinite)
	) {
		return '';
	}

	return JSON.stringify(
		{
			accumulatedSquaredGradient: round(
				nextAccumulatedSquaredGradient
			),
			parameter: round(nextParameter),
			update: round(update)
		},
		null,
		2
	);
};

export const Tool: TypeTool = {
	name: 'Adagrad Optimizer Step Calculator',
	slug: 'optimization/adagrad-step',
	intro:
		'Calculate one scalar Adagrad parameter update and its accumulated gradient state.',
	tool: calculateAdagradStep,
	i: [
		{
			example: '1',
			label: 'Parameter',
			placeholder: 'Current parameter value',
			type: 'number',
			value: 1
		},
		{
			example: '0.1',
			label: 'Gradient',
			placeholder: 'Current gradient',
			type: 'number',
			value: 0.1
		},
		{
			example: '0',
			label: 'Accumulated Squared Gradient',
			placeholder: 'Previous accumulated gradient',
			type: 'number',
			value: 0
		},
		{
			example: '0.01',
			label: 'Learning Rate',
			placeholder: 'Positive learning rate',
			type: 'number',
			value: 0.01
		},
		{
			example: '0.00000001',
			label: 'Epsilon',
			placeholder: 'Positive stability constant',
			type: 'number',
			value: 0.00000001
		}
	],
	o: [
		{
			example: '{ "parameter": 0.99, "update": 0.01 }',
			label: 'Adagrad Step',
			placeholder: 'Updated optimizer state will appear here...',
			render: 'textarea',
			type: 'text'
		}
	],
	cite: [
		{
			title:
				'Adaptive Subgradient Methods for Online Learning and Stochastic Optimization',
			url: 'https://jmlr.org/papers/v12/duchi11a.html'
		}
	]
};

export default Tool;

Description

Browse the implementation files for Adagrad Optimizer Step Calculator.

References

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

Similar or alternative tools