# 线性回归任务

# 什么是线性回归

利用数理统计中回归分析，来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法

# 准备可视化训练数据

安装可视化库

yarn add @tensorflow/tfjs-vis

linear-regression/script.js

import * as tfvis from "@tensorflow/tfjs-vis";

window.onload = () => {
  const xs = [1, 2, 3, 4];
  const ys = [1, 3, 5, 7];

  tfvis.render.scatterplot(
    { name: "线性回归训练集" },
    { values: xs.map((x, i) => ({ x, y: ys[i] })) },
    { xAxisDomain: [0, 5], yAxisDomain: [0, 8] }
  );
};

1
2
3
4
5
6
7
8
9
10
11
12

tensorflow

# 定义模型结构：单层单个神经元组成的神经网络

初始化一个神经网络模型
为神经网络模型添加层
设计层的神经元个数和inputShape（输入形状）

import * as tf from '@tensorflow/tfjs';
import * as tfvis from '@tensorflow/tfjs-vis';

window.onload = () => {
    const xs = [1, 2, 3, 4];
    const ys = [1, 3, 5, 7];

    tfvis.render.scatterplot(
        { name: '线性回归训练集' },
        { values: xs.map((x, i) => ({ x, y: ys[i] })) },
        { xAxisDomain: [0, 5], yAxisDomain: [0, 8] }
    )

    // ----------------------------------------------------------------
    // sequential 连续模型，上一个的输出是下一个的输入
    const model = tf.sequential()
    // units 神经元个数
    // inputShape 输入形状 就是 tf.tensor() 里的shape
    model.add(tf.layers.dense({units: 1, inputShape: [1]}))
    // ----------------------------------------------------------------
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 损失函数：均方误差（MSE）优化器

import * as tf from '@tensorflow/tfjs';
import * as tfvis from '@tensorflow/tfjs-vis';
import { mod } from '@tensorflow/tfjs';

window.onload = () => {
    const xs = [1, 2, 3, 4];
    const ys = [1, 3, 5, 7];

    tfvis.render.scatterplot(
        { name: '线性回归训练集' },
        { values: xs.map((x, i) => ({ x, y: ys[i] })) },
        { xAxisDomain: [0, 5], yAxisDomain: [0, 8] }
    )
    // sequential 连续模型，上一个的输出是下一个的输入
    const model = tf.sequential()
    // units 神经元个数
    // inputShape 输入形状 就是 tf.tensor() 里的shape
    model.add(tf.layers.dense({ units: 1, inputShape: [1] }));
    // -------------------------------------------------------------------
    // 设置损失函数loss 均方误差  优化器optimizer sgd的参数是学习率
    model.compile({ loss: tf.losses.meanSquaredError, optimizer: tf.train.sgd(0.1) });
    // -------------------------------------------------------------------
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 训练模型

import * as tf from '@tensorflow/tfjs';
import * as tfvis from '@tensorflow/tfjs-vis';

window.onload = async () => {
    const xs = [1, 2, 3, 4];
    const ys = [1, 3, 5, 7];

    tfvis.render.scatterplot(
        { name: '线性回归训练集' },
        { values: xs.map((x, i) => ({ x, y: ys[i] })) },
        { xAxisDomain: [0, 5], yAxisDomain: [0, 8] }
    )
    // sequential 连续模型，上一个的输出是下一个的输入
    const model = tf.sequential()
    // units 神经元个数
    // inputShape 输入形状 就是 tf.tensor() 里的shape
    model.add(tf.layers.dense({ units: 1, inputShape: [1] }));
    // 设置损失函数loss 均方误差  优化器optimizer sgd的参数是学习率
    model.compile({ loss: tf.losses.meanSquaredError, optimizer: tf.train.sgd(0.1) });

    // -------------------------------------------------------------
    const inputs = tf.tensor(xs);
    const labels = tf.tensor(ys);
    await model.fit(inputs, labels, {
        // 小批量的学习，一次学习几个点
        batchSize: 4,
        // 训练数据的次数
        epochs: 100,
        // 可视化训练过程
        callbacks: tfvis.show.fitCallbacks(
            { name: '训练过程' },
            ['loss']
        )
    });
    // -------------------------------------------------------------
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 预测值

import * as tf from '@tensorflow/tfjs';
import * as tfvis from '@tensorflow/tfjs-vis';

window.onload = async () => {
    const xs = [1, 2, 3, 4];
    const ys = [1, 3, 5, 7];

    tfvis.render.scatterplot(
        { name: '线性回归训练集' },
        { values: xs.map((x, i) => ({ x, y: ys[i] })) },
        { xAxisDomain: [0, 5], yAxisDomain: [0, 8] }
    )
    // sequential 连续模型，上一个的输出是下一个的输入
    const model = tf.sequential()
    // units 神经元个数
    // inputShape 输入形状 就是 tf.tensor() 里的shape
    model.add(tf.layers.dense({ units: 1, inputShape: [1] }));
    // 设置损失函数loss 均方误差  优化器optimizer sgd的参数是学习率
    model.compile({ loss: tf.losses.meanSquaredError, optimizer: tf.train.sgd(0.1) });

    const inputs = tf.tensor(xs);
    const labels = tf.tensor(ys);
    await model.fit(inputs, labels, {
        // 小批量的学习，一次学习几个点
        batchSize: 4,
        // 训练数据的次数
        epochs: 100,
        // 可视化训练过程
        callbacks: tfvis.show.fitCallbacks(
            { name: '训练过程' },
            ['loss']
        )
    });
    // --------------------------------------------------------------
    // 预测值 输入要选的点，转成tensor，得到的输出值也是tensor
    const output = model.predict(tf.tensor([5]));
    // 输出的output也是一个tensor数据结构，需要通过 dataSync 转换成普通的数据，转出来的是个数组，我们取第0个
    alert(`如果 x 为 5, 那么预测 y 为 ${output.dataSync()[0]}`)
    // --------------------------------------------------------------
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

使用 model.predict() 进行预测
输入和输出都是 tensor 数据结构
输入和输出都和训练的数据一样的结构

← 神经网络归一化任务 →