TensorFlow.js 层与网络 #

层概述 #

层是神经网络的基本构建块，每一层接收输入、进行变换、产生输出。

text

┌─────────────────────────────────────────────────────────────┐
│                      层的类型                                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │  核心层      │  │  卷积层      │  │  循环层      │         │
│  │  Dense      │  │  Conv2D     │  │  LSTM       │         │
│  │  Dropout    │  │  Conv1D     │  │  GRU        │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │  池化层      │  │  正则化层    │  │  嵌入层      │         │
│  │  MaxPool    │  │  BatchNorm  │  │  Embedding  │         │
│  │  AvgPool    │  │  LayerNorm  │  │             │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心层 #

Dense（全连接层） #

最常用的层，每个输入节点与每个输出节点相连。

javascript

const dense = tf.layers.dense({
  units: 64,
  activation: 'relu',
  useBias: true,
  kernelInitializer: 'glorotNormal',
  biasInitializer: 'zeros',
  kernelRegularizer: tf.regularizers.l2({ l2: 0.01 }),
  inputShape: [10]
});

参数说明 #

参数	说明	默认值
units	输出维度	必填
activation	激活函数	linear
useBias	是否使用偏置	true
kernelInitializer	权重初始化	glorotNormal
biasInitializer	偏置初始化	zeros

激活函数 #

javascript

tf.layers.dense({ units: 64, activation: 'relu' });
tf.layers.dense({ units: 64, activation: 'sigmoid' });
tf.layers.dense({ units: 64, activation: 'tanh' });
tf.layers.dense({ units: 64, activation: 'softmax' });
tf.layers.dense({ units: 64, activation: 'elu' });
tf.layers.dense({ units: 64, activation: 'selu' });
tf.layers.dense({ units: 64, activation: 'linear' });

Activation（激活层） #

单独的激活函数层。

javascript

tf.layers.activation({ activation: 'relu' });
tf.layers.activation({ activation: 'softmax' });

Dropout（丢弃层） #

随机丢弃部分神经元，防止过拟合。

javascript

const dropout = tf.layers.dropout({
  rate: 0.5,
  noiseShape: null,
  seed: null
});

使用示例 #

javascript

const model = tf.sequential();
model.add(tf.layers.dense({ units: 128, inputShape: [784], activation: 'relu' }));
model.add(tf.layers.dropout({ rate: 0.5 }));
model.add(tf.layers.dense({ units: 64, activation: 'relu' }));
model.add(tf.layers.dropout({ rate: 0.3 }));
model.add(tf.layers.dense({ units: 10, activation: 'softmax' }));

Flatten（展平层） #

将多维输入展平为一维。

javascript

const flatten = tf.layers.flatten({
  inputShape: [28, 28, 1]
});

Reshape（重塑层） #

改变输入的形状。

javascript

const reshape = tf.layers.reshape({
  targetShape: [7, 7, 64]
});

Permute（置换层） #

置换输入的维度顺序。

javascript

const permute = tf.layers.permute({
  dims: [2, 1, 3]
});

RepeatVector（重复向量层） #

重复输入 n 次。

javascript

const repeat = tf.layers.repeatVector({
  n: 3
});

卷积层 #

Conv2D（二维卷积） #

用于图像处理。

javascript

const conv2d = tf.layers.conv2d({
  filters: 32,
  kernelSize: 3,
  strides: 1,
  padding: 'same',
  activation: 'relu',
  inputShape: [28, 28, 1]
});

参数说明 #

参数	说明	默认值
filters	卷积核数量	必填
kernelSize	卷积核大小	必填
strides	步长	1
padding	填充方式	valid
activation	激活函数	linear

padding 选项 #

javascript

tf.layers.conv2d({ padding: 'valid' });
tf.layers.conv2d({ padding: 'same' });

Conv1D（一维卷积） #

用于序列处理。

javascript

const conv1d = tf.layers.conv1d({
  filters: 64,
  kernelSize: 3,
  strides: 1,
  padding: 'same',
  activation: 'relu',
  inputShape: [100, 1]
});

Conv2DTranspose（转置卷积） #

用于上采样。

javascript

const conv2dTranspose = tf.layers.conv2dTranspose({
  filters: 32,
  kernelSize: 3,
  strides: 2,
  padding: 'same',
  inputShape: [7, 7, 128]
});

SeparableConv2D（深度可分离卷积） #

更高效的卷积方式。

javascript

const separableConv = tf.layers.separableConv2d({
  filters: 32,
  kernelSize: 3,
  depthMultiplier: 1,
  padding: 'same',
  inputShape: [28, 28, 3]
});

池化层 #

MaxPooling2D（最大池化） #

javascript

const maxPool = tf.layers.maxPooling2d({
  poolSize: 2,
  strides: 2,
  padding: 'valid'
});

AveragePooling2D（平均池化） #

javascript

const avgPool = tf.layers.averagePooling2d({
  poolSize: 2,
  strides: 2,
  padding: 'valid'
});

GlobalMaxPooling2D（全局最大池化） #

javascript

const globalMaxPool = tf.layers.globalMaxPooling2d();

GlobalAveragePooling2D（全局平均池化） #

javascript

const globalAvgPool = tf.layers.globalAveragePooling2d();

一维池化 #

javascript

const maxPool1d = tf.layers.maxPooling1d({
  poolSize: 2,
  strides: 2
});

const avgPool1d = tf.layers.averagePooling1d({
  poolSize: 2,
  strides: 2
});

循环层 #

LSTM（长短期记忆网络） #

javascript

const lstm = tf.layers.lstm({
  units: 128,
  returnSequences: true,
  returnState: false,
  inputShape: [10, 32]
});

参数说明 #

参数	说明	默认值
units	输出维度	必填
returnSequences	是否返回完整序列	false
returnState	是否返回状态	false
activation	激活函数	tanh
recurrentActivation	循环激活函数	sigmoid

GRU（门控循环单元） #

javascript

const gru = tf.layers.gru({
  units: 128,
  returnSequences: true,
  inputShape: [10, 32]
});

SimpleRNN（简单循环神经网络） #

javascript

const rnn = tf.layers.simpleRNN({
  units: 64,
  returnSequences: false,
  inputShape: [10, 32]
});

Bidirectional（双向包装器） #

javascript

const bidirectional = tf.layers.bidirectional({
  layer: tf.layers.lstm({ units: 64 }),
  mergeMode: 'concat'
});

使用示例 #

javascript

const model = tf.sequential();
model.add(tf.layers.lstm({
  units: 64,
  returnSequences: true,
  inputShape: [10, 32]
}));
model.add(tf.layers.lstm({
  units: 32,
  returnSequences: false
}));
model.add(tf.layers.dense({ units: 10, activation: 'softmax' }));

正则化层 #

BatchNormalization（批归一化） #

javascript

const batchNorm = tf.layers.batchNormalization({
  axis: -1,
  momentum: 0.99,
  epsilon: 0.001,
  center: true,
  scale: true
});

LayerNormalization（层归一化） #

javascript

const layerNorm = tf.layers.layerNormalization({
  axis: -1,
  epsilon: 0.001,
  center: true,
  scale: true
});

使用示例 #

javascript

const model = tf.sequential();
model.add(tf.layers.dense({ units: 128, inputShape: [784] }));
model.add(tf.layers.batchNormalization());
model.add(tf.layers.activation({ activation: 'relu' }));
model.add(tf.layers.dense({ units: 64 }));
model.add(tf.layers.batchNormalization());
model.add(tf.layers.activation({ activation: 'relu' }));
model.add(tf.layers.dense({ units: 10, activation: 'softmax' }));

嵌入层 #

Embedding（嵌入层） #

将整数索引映射为稠密向量。

javascript

const embedding = tf.layers.embedding({
  inputDim: 10000,
  outputDim: 128,
  inputLength: 100
});

使用示例 #

javascript

const model = tf.sequential();
model.add(tf.layers.embedding({
  inputDim: 10000,
  outputDim: 128,
  inputLength: 100
}));
model.add(tf.layers.lstm({ units: 64 }));
model.add(tf.layers.dense({ units: 1, activation: 'sigmoid' }));

合并层 #

Concatenate（拼接） #

javascript

const concat = tf.layers.concatenate({ axis: -1 });

Add（相加） #

javascript

const add = tf.layers.add();

Subtract（相减） #

javascript

const subtract = tf.layers.subtract();

Multiply（相乘） #

javascript

const multiply = tf.layers.multiply();

Average（平均） #

javascript

const average = tf.layers.average();

Maximum（最大值） #

javascript

const maximum = tf.layers.maximum();

Minimum（最小值） #

javascript

const minimum = tf.layers.minimum();

Dot（点积） #

javascript

const dot = tf.layers.dot({ axes: -1 });

注意力层 #

Attention（注意力） #

javascript

const attention = tf.layers.attention({
  useScale: true
});

MultiHeadAttention（多头注意力） #

javascript

const multiHead = tf.layers.multiHeadAttention({
  numHeads: 8,
  keyDim: 64
});

自定义层 #

创建自定义层 #

javascript

class CustomDense extends tf.layers.Layer {
  constructor(units) {
    super({});
    this.units = units;
  }

  build(inputShape) {
    this.kernel = this.addWeight(
      'kernel',
      [inputShape[1], this.units],
      'float32',
      tf.initializers.glorotNormal()
    );
    this.bias = this.addWeight(
      'bias',
      [this.units],
      'float32',
      tf.initializers.zeros()
    );
  }

  call(inputs) {
    return inputs.matMul(this.kernel.read()).add(this.bias.read());
  }

  static get className() {
    return 'CustomDense';
  }
}

tf.serialization.registerClass(CustomDense);

使用自定义层 #

javascript

const model = tf.sequential();
model.add(new CustomDense(64));
model.add(new CustomDense(10));

层配置最佳实践 #

权重初始化 #

javascript

tf.layers.dense({
  units: 64,
  kernelInitializer: 'glorotNormal',
  biasInitializer: 'zeros'
});

tf.layers.dense({
  units: 64,
  kernelInitializer: 'heNormal'
});

tf.layers.dense({
  units: 64,
  kernelInitializer: tf.initializers.randomNormal({ mean: 0, stddev: 0.05 })
});

正则化 #

javascript

tf.layers.dense({
  units: 64,
  kernelRegularizer: tf.regularizers.l1({ l1: 0.01 }),
  biasRegularizer: tf.regularizers.l2({ l2: 0.01 })
});

tf.layers.dense({
  units: 64,
  activityRegularizer: tf.regularizers.l1l2({ l1: 0.01, l2: 0.01 })
});

约束 #

javascript

tf.layers.dense({
  units: 64,
  kernelConstraint: tf.constraints.maxNorm({ maxValue: 2 })
});

常见网络架构 #

MLP（多层感知机） #

javascript

const mlp = tf.sequential({
  layers: [
    tf.layers.dense({ units: 128, inputShape: [784], activation: 'relu' }),
    tf.layers.dropout({ rate: 0.5 }),
    tf.layers.dense({ units: 64, activation: 'relu' }),
    tf.layers.dropout({ rate: 0.3 }),
    tf.layers.dense({ units: 10, activation: 'softmax' })
  ]
});

CNN（卷积神经网络） #

javascript

const cnn = tf.sequential({
  layers: [
    tf.layers.conv2d({ filters: 32, kernelSize: 3, activation: 'relu', inputShape: [28, 28, 1] }),
    tf.layers.maxPooling2d({ poolSize: 2 }),
    tf.layers.conv2d({ filters: 64, kernelSize: 3, activation: 'relu' }),
    tf.layers.maxPooling2d({ poolSize: 2 }),
    tf.layers.flatten(),
    tf.layers.dense({ units: 128, activation: 'relu' }),
    tf.layers.dense({ units: 10, activation: 'softmax' })
  ]
});

RNN（循环神经网络） #

javascript

const rnn = tf.sequential({
  layers: [
    tf.layers.embedding({ inputDim: 10000, outputDim: 128, inputLength: 100 }),
    tf.layers.lstm({ units: 64, returnSequences: true }),
    tf.layers.lstm({ units: 32 }),
    tf.layers.dense({ units: 1, activation: 'sigmoid' })
  ]
});

下一步 #

现在你已经掌握了各种层的使用，接下来学习模型训练，了解如何训练神经网络！