main function

void main()

Implementation

void main() {
  print('========================================');
  print(' TRANSFORMER LAYER BENCHMARK (CPU ONLY) ');
  print('========================================\n');

  int iterations = 100;

  // Standard dimension variables for benchmarking
  int vocabSize = 10000;
  int embedDim = 128;
  int seqLength = 64;
  int batchSize = 16;
  int dModel = 128;
  int numHeads = 8;
  int dff = 512;

  // 1. EmbeddingLayer (1D input)
  EmbeddingLayer embLayer = EmbeddingLayer(vocabSize, embedDim);
  Tensor<Vector> embInput = generateIndexVector(seqLength, vocabSize);
  runBenchmark<Vector, Matrix>('EmbeddingLayer (Seq: $seqLength, Dim: $embedDim)', embLayer, embInput, iterations);

  // 2. EmbeddingLayerMatrix (2D Input - Batch processing)
  EmbeddingLayerMatrix embLayerMatrix = EmbeddingLayerMatrix(vocabSize, embedDim);
  Tensor<Matrix> embMatrixInput = generateIndexMatrix(batchSize, seqLength, vocabSize);
  runBenchmark<Matrix, Tensor3D>('EmbeddingLayerMatrix (Batch: $batchSize, Seq: $seqLength, Dim: $embedDim)', embLayerMatrix, embMatrixInput, iterations);

  // 3. GlobalAveragePooling1D
  GlobalAveragePooling1D globalPool = GlobalAveragePooling1D();
  Tensor<Matrix> poolInput = generateMatrix(seqLength, dModel);
  runBenchmark<Matrix, Vector>('GlobalAveragePooling1D (Seq: $seqLength, Feat: $dModel)', globalPool, poolInput, iterations);

  // 4. LayerNormalization
  LayerNormalization layerNorm = LayerNormalization();
  Tensor<Matrix> normInput = generateMatrix(seqLength, dModel);
  runBenchmark<Matrix, Matrix>('LayerNormalization (Seq: $seqLength, Feat: $dModel)', layerNorm, normInput, iterations);

  // 5. PositionalEncoding
  PositionalEncoding posEncoding = PositionalEncoding(1024, dModel);
  Tensor<Matrix> posInput = generateMatrix(seqLength, dModel);
  runBenchmark<Matrix, Matrix>('PositionalEncoding (Seq: $seqLength, dModel: $dModel)', posEncoding, posInput, iterations);

  // 6. MultiHeadAttention
  MultiHeadAttention mha = MultiHeadAttention(dModel, numHeads);
  Tensor<Matrix> mhaInput = generateMatrix(seqLength, dModel);
  runBenchmark<Matrix, Matrix>('MultiHeadAttention (Seq: $seqLength, dModel: $dModel, Heads: $numHeads)', mha, mhaInput, iterations);

  // 7. TransformerEncoderBlock
  TransformerEncoderBlock transformerBlock = TransformerEncoderBlock(dModel, numHeads, dff);
  Tensor<Matrix> blockInput = generateMatrix(seqLength, dModel);
  runBenchmark<Matrix, Matrix>('TransformerEncoderBlock (Seq: $seqLength, dModel: $dModel, dff: $dff)', transformerBlock, blockInput, iterations);

  print('========================================');
  print('         BENCHMARK COMPLETE             ');
  print('========================================');
}