Published
Edited
Apr 11, 2021
Importers
function apply(params, xt) {
let [w, b] = params;
return xt.dot(w).add(b).cos()
}
init_params = [
tf.randomNormal([1]),
tf.randomNormal([1]).squeeze(),
]
n = 100
function make_regression(n, p) {
let _ = Math.seedrandom(7)
let xt = tf.randomUniform([n, p], -3, 3.)
let w = tf.randomNormal([p]).mul(2.)
let b = tf.randomNormal([1]).squeeze()
let noise = tf.randomNormal([n]).mul(0.2)
let yt = xt.dot(w).add(b).sin().add(noise)
let reg = {xt: xt, yt: yt, w: w, b: b}
return reg
}
reg = make_regression(n, 1)
yt = reg["yt"]
y = yt.array()
x = xt.array()
xt = reg["xt"]
x.map((e, i) => (e, i))
data = x.map((e, i) => ({x: e, y: y[i], step: i}))
function make_mse(apply_fn, xt, yt) {
return (...params) => {
let pred = apply_fn(params, xt)
return pred.sub(yt).square().mean([0])
}
}
grad_loss = tf.valueAndGrads(loss)
loss = make_mse(apply, xt, yt)
loss_batch = make_mse(apply, xt, yt.reshape([-1, 1]))
// compute vectorized gradient for e.g. a gradient grid
// grid = tf.stack([xtiled, ytiled], [1]).reshape([n_points ** 2, 2])
// splitted = tf.split(grid, 2, 1)
// vl.markPoint().data(
// recordify(xtiled.arraySync(), ytiled.arraySync(), "xy")
// ).encode(vl.x().fieldQ('x'),
// vl.y().fieldQ('y'),
// // vl.color().fieldN('origin'),
// // vl.tooltip(['origin']) // show the Name and Origin fields in a tooltip
// ).render()
function optimize(grad_loss, epochs, lr, momentum, init_params){
let params = init_params;
let z = params.map(w => 0);
let memo = {loss: [], params: []};
for (let i = 0; i <= epochs; i++) {
let {value, grads} = grad_loss(params);
z = grads.map((g, i) => tf.add(g, tf.mul(momentum, z[i])))
params = params.map((w, i) => tf.sub(w, z[i].mul(lr))) ;
memo["loss"].push(value);
memo["params"].push(params);
}
return memo
}
memo_params = res.params
final_params = memo_params[n_train]
losses = res.loss
loss_data = losses.map((l, i) => ({loss: l.dataSync(), step: i}))
res = optimize(grad_loss, n_train, lr, momentum, init_params)
loss_chart = vl.markLine().data(loss_data).encode(
vl.x().fieldQ('step'),
vl.y().fieldQ('loss'),
).width(600)
pred_chart = vl.markPoint().data(pred_data).encode(
vl.x().fieldQ('x'),
vl.y().fieldQ('y'),
vl.color().fieldN('origin'),
vl.tooltip(['origin'])
).width(600)
Promise.all(final_params.map((x) => x.array()))
ypred = apply(final_params, xt).array()
pred_data = [
...x.map((e, i) => ({x: e, y: y[i], step: i, origin: "truth"})),
...x.map((e, i) => ({x: e, y: ypred[i], step: i, origin: "pred"}))
]
init_meta = [tf.tensor([0.9]), tf.tensor([0.85])]
memo_meta = optimize(grad_meta_loss, 10, lr_meta, momentum_meta, init_meta)
function meta_loss (lr, momentum) {
let res = optimize(grad_loss, 20, lr, momentum, init_params)
return res.loss[res.loss.length - 1]
}
grad_meta_loss = tf.valueAndGrads(meta_loss)
meta_loss_data = memo_meta.loss.map((l, i) => ({loss: l.dataSync(), step: i}))
memo_meta.params[memo_meta.params.length -1][0].array()
memo_meta.loss[memo_meta.loss.length - 1].array()
md`## Imports`
import {Range, Selection} from "@observablehq/inputs"
import {vl} from '@vega/vega-lite-api'
d3 = require("d3@6")
// dfd = require('danfojs/dist/index.min.js').catch(() => {
// window.dfd.Series.prototype.print = window.dfd.DataFrame.prototype.print = function() { return print(this) };
// return window.dfd;
// })
// df_data = new dfd.DataFrame(data)
tf = {
let tf = await require("@tensorflow/tfjs")
tf.setBackend("cpu")
return tf
}
tf.getBackend()
// import { render, showLayer, showModelSummary, showValuesDistribution, showHistory } from '@horaceg/tensorflow-vis-api';
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
