instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from the video
  feed. For each detected face, it draws a red rectangle around the face and
  blue dots for facial landmarks on a canvas overlaying the video.index.js
  
  const stats = new Stats();
  stats.showPanel(0);
  document.body.prepend(stats.domElement);
  
  let model, ctx, videoWidth, videoHeight, video, canvas;
  
  const state = {
   backend: "wasm",
  };
  
  const gui = new dat.GUI();
  gui
   .add(state, "backend", ["wasm", "webgl", "cpu"])
   .onChange(async (backend) => {
   await tf.setBackend(backend);
   addFlagLables();
   });
  
  async function addFlagLables() {
   if (!document.querySelector("#simd_supported")) {
   const simdSupportLabel = document.createElement("div");
   simdSupportLabel.id = "simd_supported";
   simdSupportLabel.style = "font-weight: bold";
   const simdSupported = await tf.env().getAsync("WASM_HAS_SIMD_SUPPORT");
   simdSupportLabel.innerHTML = `SIMD supported: <span class=${simdSupported}>${simdSupported}<span>`;
   document.querySelector("#description").appendChild(simdSupportLabel);
   }
  
   if (!document.querySelector("#threads_supported")) {
   const threadSupportLabel = document.createElement("div");
   threadSupportLabel.id = "threads_supported";
   threadSupportLabel.style = "font-weight: bold";
   const threadsSupported = await tf
   .env()
   .getAsync("WASM_HAS_MULTITHREAD_SUPPORT");
   threadSupportLabel.innerHTML = `Threads supported: <span class=${threadsSupported}>${threadsSupported}</span>`;
   document.querySelector("#description").appendChild(threadSupportLabel);
   }
  }
  
  async function setupCamera() {
   video = document.getElementById("video");
  
   const stream = await navigator.mediaDevices.getUserMedia({
   audio: false,
   video: { facingMode: "user" },
   });
   video.srcObject = stream;
  
   return new Promise((resolve) => {
   video.onloadedmetadata = () => {
   resolve(video);
   };
   });
  }
  
  const renderPrediction = async () => {
   stats.begin();
  
   const returnTensors = false;
   const flipHorizontal = true;
   const annotateBoxes = true;
   const predictions = await model.estimateFaces(
   video,
   returnTensors,
   flipHorizontal,
   annotateBoxes,
   );
  
   if (predictions.length > 0) {
   ctx.clearRect(0, 0, canvas.width, canvas.height);
  
   for (let i = 0; i < predictions.length; i++) {
   if (returnTensors) {
   predictions[i].topLeft = predictions[i].topLeft.arraySync();
   predictions[i].bottomRight = predictions[i].bottomRight.arraySync();
   if (annotateBoxes) {
   predictions[i].landmarks = predictions[i].landmarks.arraySync();
   }
   }
  
   const start = predictions[i].topLeft;
   const end = predictions[i].bottomRight;
   const size = [end[0] - start[0], end[1] - start[1]];
   ctx.fillStyle = "rgba(255, 0, 0, 0.5)";
   ctx.fillRect(start[0], start[1], size[0], size[1]);
  
   if (annotateBoxes) {
   const landmarks = predictions[i].landmarks;
  
   ctx.fillStyle = "blue";
   for (let j = 0; j < landmarks.length; j++) {
   const x = landmarks[j][0];
   const y = landmarks[j][1];
   ctx.fillRect(x, y, 5, 5);
   }
   }
   }
   }
  
   stats.end();
  
   requestAnimationFrame(renderPrediction);
  };
  
  const setupPage = async () => {
   await tf.setBackend(state.backend);
   addFlagLables();
   await setupCamera();
   video.play();
  
   videoWidth = video.videoWidth;
   videoHeight = video.videoHeight;
   video.width = videoWidth;
   video.height = videoHeight;
  
   canvas = document.getElementById("output");
   canvas.width = videoWidth;
   canvas.height = videoHeight;
   ctx = canvas.getContext("2d");
   ctx.fillStyle = "rgba(255, 0, 0, 0.5)";
  
   model = await blazeface.load();
  
   renderPrediction();
  };
  
  setupPage();The tf-backend-wasm.js fileThe tf-backend-wasm.js file is part of the
  TensorFlow.js library.
  It contains initialization logic for the TensorFlow.js WASM backend, some
  utilities for interacting with the WASM binaries, and functions to set custom
  paths for the WASM binaries.The tfjs-backend-wasm-simd.wasm fileThe tfjs-backend-wasm-simd.wasm file is part of the
  TensorFlow.js library.
  It's a WASM binary that's used for the WebAssembly
  backend, specifically optimized to utilize SIMD (Single Instruction, Multiple
  Data) instructions.Explore the DockerfileIn a Docker-based project, the Dockerfile serves as the foundational
  asset for building your application's environment.A Dockerfile is a text file that instructs Docker how to create an image of your
  application's environment. An image contains everything you want and
  need when running application, such as files, packages, and tools.The following is the Dockerfile for this project.
  ```