Samouczek dotyczący interfejsu API sieci WebNN

Aby uzyskać wprowadzenie do sieci WebNN, w tym informacje o obsłudze systemu operacyjnego, obsłudze modelu i nie tylko, odwiedź stronę WebNN Overview (Omówienie sieci WebNN).

W tym samouczku pokazano, jak używać WebNN z ONNX Runtime Web do zbudowania systemu klasyfikacji obrazów w internecie, który jest sprzętowo przyspieszany dzięki procesorowi GPU na urządzeniu. Będziemy korzystać z modelu MobileNetV2 , który jest modelem open source w aplikacji Hugging Face używanym do klasyfikowania obrazów.

Jeśli chcesz wyświetlić i uruchomić końcowy kod tego samouczka, możesz go znaleźć w witrynie GitHub dla deweloperów sieci WebNN w wersji zapoznawczej.

Uwaga / Notatka

API WebNN jest rekomendacją kandydacką W3C i jest na wczesnym etapie wersji poglądowej dla deweloperów. Niektóre funkcje są ograniczone. Mamy listę bieżącej pomocy technicznej i stanu implementacji.

Wymagania i konfiguracja:

Konfigurowanie systemu Windows

Upewnij się, że masz odpowiednie wersje sterowników przeglądarki Edge, Windows i sprzętu zgodnie z opisem w sekcji Wymagania sieci WebNN.

Konfigurowanie przeglądarki Edge

  1. Pobierz i zainstaluj program Microsoft Edge Dev.

  2. Uruchom przeglądarkę Edge Beta i przejdź do about:flags na pasku adresu.

  3. Wyszukaj "WebNN API", kliknij menu rozwijane i ustaw na 'Enabled'.

  4. Uruchom ponownie przeglądarkę Edge, gdy zostanie wyświetlony monit.

Ilustracja funkcji WebNN włączonej w wersji beta przeglądarki Edge

Konfigurowanie środowiska deweloperskiego

  1. Pobierz i zainstaluj program Visual Studio Code (VSCode).

  2. Uruchom program VSCode.

  3. Pobierz i zainstaluj rozszerzenie Live Server dla programu VSCode w programie VSCode .

  4. Wybierz pozycję File --> Open Folderi utwórz pusty folder w żądanej lokalizacji.

Krok 1. Inicjowanie aplikacji internetowej

  1. Aby rozpocząć, utwórz nową index.html stronę. Dodaj następujący standardowy kod do nowej strony:
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My Website</title>
  </head>
  <body>
    <main>
        <h1>Welcome to My Website</h1>
    </main>
  </body>
</html>
  1. Sprawdź, czy standardowy kod i konfiguracja dewelopera działały, wybierając przycisk Przejdź na żywo w prawym dolnym rogu programu VSCode. Powinno to uruchomić serwer lokalny w przeglądarce Edge Beta, z kodem szablonowym.
  2. Teraz utwórz nowy plik o nazwie main.js. Będzie to zawierać kod javascript aplikacji.
  3. Następnie utwórz podfolder z katalogu głównego o nazwie images. Pobierz i zapisz dowolny obraz w folderze. Na potrzeby tego pokazu użyjemy domyślnej nazwy image.jpg.
  4. Pobierz model mobilenet z zoo modelu ONNX. W tym poradniku będziesz korzystać z pliku mobilenet2-10.onnx. Zapisz ten model w folderze głównym aplikacji internetowej.
  5. Na koniec pobierz i zapisz ten plik klas obrazów, imagenetClasses.js. Zapewnia to 1000 typowych klasyfikacji obrazów do użycia przez model.

Krok 2. Dodawanie elementów interfejsu użytkownika i funkcji nadrzędnej

  1. W treści <main> tagów HTML dodanych w poprzednim kroku zastąp istniejący kod następującymi elementami. Spowoduje to utworzenie przycisku i wyświetlenie obrazu domyślnego.
<h1>Image Classification Demo!</h1> 
<div><img src="./images/image.jpg"></div> 
<button onclick="classifyImage('./images/image.jpg')"  type="button">Click Me to Classify Image!</button> 
<h1 id="outputText"> This image displayed is ... </h1>
  1. Teraz dodasz ONNX Runtime Web do swojej strony, czyli bibliotekę JavaScript, której będziesz używać do uzyskiwania dostępu do interfejsu API WebNN. W treści <head> tagów HTML dodaj następujące linki źródłowe javascript.
<script src="./main.js"></script> 
<script src="imagenetClasses.js"></script>
<script src="https://cdn.jsdelivr.net/npm/onnxruntime-web@1.18.0-dev.20240311-5479124834/dist/ort.webgpu.min.js"></script>
  1. main.js Otwórz plik i dodaj następujący fragment kodu.
async function classifyImage(pathToImage){ 
  var imageTensor = await getImageTensorFromPath(pathToImage); // Convert image to a tensor
  var predictions = await runModel(imageTensor); // Run inference on the tensor
  console.log(predictions); // Print predictions to console
  document.getElementById("outputText").innerHTML += predictions[0].name; // Display prediction in HTML
}

Krok 3. Wstępne przetwarzanie danych

  1. Funkcja, którą właśnie dodano, wywołuje metodę getImageTensorFromPath, inną funkcję, którą musisz zaimplementować. Dodasz go poniżej, a także inną funkcję asynchroniczną, która wywołuje w celu pobrania samego obrazu.
  async function getImageTensorFromPath(path, width = 224, height = 224) {
    var image = await loadImagefromPath(path, width, height); // 1. load the image
    var imageTensor = imageDataToTensor(image); // 2. convert to tensor
    return imageTensor; // 3. return the tensor
  } 

  async function loadImagefromPath(path, resizedWidth, resizedHeight) {
    var imageData = await Jimp.read(path).then(imageBuffer => { // Use Jimp to load the image and resize it.
      return imageBuffer.resize(resizedWidth, resizedHeight);
    });

    return imageData.bitmap;
  }
  1. Należy również dodać funkcję imageDataToTensor, o której mowa powyżej, która przetworzy załadowany obraz na format tensora, który będzie działać z naszym modelem ONNX. Jest to bardziej zaangażowana funkcja, choć może wydawać się znana, jeśli wcześniej pracowałeś z podobnymi aplikacjami klasyfikacji obrazów. Aby uzyskać rozszerzone wyjaśnienie, możesz wyświetlić ten samouczek ONNX.
  function imageDataToTensor(image) {
    var imageBufferData = image.data;
    let pixelCount = image.width * image.height;
    const float32Data = new Float32Array(3 * pixelCount); // Allocate enough space for red/green/blue channels.

    // Loop through the image buffer, extracting the (R, G, B) channels, rearranging from
    // packed channels to planar channels, and converting to floating point.
    for (let i = 0; i < pixelCount; i++) {
      float32Data[pixelCount * 0 + i] = imageBufferData[i * 4 + 0] / 255.0; // Red
      float32Data[pixelCount * 1 + i] = imageBufferData[i * 4 + 1] / 255.0; // Green
      float32Data[pixelCount * 2 + i] = imageBufferData[i * 4 + 2] / 255.0; // Blue
      // Skip the unused alpha channel: imageBufferData[i * 4 + 3].
    }
    let dimensions = [1, 3, image.height, image.width];
    const inputTensor = new ort.Tensor("float32", float32Data, dimensions);
    return inputTensor;
  }

Krok 4. Wywołanie sieci Web środowiska uruchomieniowego ONNX

  1. Teraz dodałeś wszystkie funkcje potrzebne do pobrania obrazu i przekształcenia go w tensor. Teraz, korzystając z biblioteki internetowej środowiska uruchomieniowego ONNX załadowanego powyżej, uruchomisz model. Należy pamiętać, że aby użyć WebNN, wystarczy określić executionProvider = "webnn" — dzięki obsłudze środowiska uruchomieniowego ONNX, włączenie WebNN jest bardzo proste.
  async function runModel(preprocessedData) { 
    // Set up environment.
    ort.env.wasm.numThreads = 1; 
    ort.env.wasm.simd = true; 
    // Uncomment for additional information in debug builds:
    // ort.env.wasm.proxy = true; 
    // ort.env.logLevel = "verbose";  
    // ort.env.debug = true; 

    // Configure WebNN.
    const modelPath = "./mobilenetv2-10.onnx";
    const devicePreference = "gpu"; // Other options include "npu" and "cpu".
    const options = {
        executionProviders: [{ name: "webnn", deviceType: devicePreference, powerPreference: "default" }],
      freeDimensionOverrides: {"batch": 1, "channels": 3, "height": 224, "width": 224}
      // The key names in freeDimensionOverrides should map to the real input dim names in the model.
      // For example, if a model's only key is batch_size, you only need to set
      // freeDimensionOverrides: {"batch_size": 1}
    };
    modelSession = await ort.InferenceSession.create(modelPath, options); 

    // Create feeds with the input name from model export and the preprocessed data. 
    const feeds = {}; 
    feeds[modelSession.inputNames[0]] = preprocessedData; 
    // Run the session inference.
    const outputData = await modelSession.run(feeds); 
    // Get output results with the output name from the model export. 
    const output = outputData[modelSession.outputNames[0]]; 
    // Get the softmax of the output data. The softmax transforms values to be between 0 and 1.
    var outputSoftmax = softmax(Array.prototype.slice.call(output.data)); 
    // Get the top 5 results.
    var results = imagenetClassesTopK(outputSoftmax, 5);

    return results; 
  }

Krok 5. Przetwarzanie danych po przetworzeniu

  1. Na koniec dodasz funkcję softmax, a następnie dodasz funkcję ostateczną w celu zwrócenia najbardziej prawdopodobnej klasyfikacji obrazu. softmax przekształca wartości w zakresie od 0 do 1, co stanowi formę prawdopodobieństwa potrzebną do tej końcowej klasyfikacji.

Najpierw dodaj następujące pliki źródłowe dla bibliotek pomocnika Jimp i Lodash w tagu main.jsgłównym .

<script src="https://cdnjs.cloudflare.com/ajax/libs/jimp/0.22.12/jimp.min.js" integrity="sha512-8xrUum7qKj8xbiUrOzDEJL5uLjpSIMxVevAM5pvBroaxJnxJGFsKaohQPmlzQP8rEoAxrAujWttTnx3AMgGIww==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

Teraz dodaj następujące funkcje do elementu main.js.

// The softmax transforms values to be between 0 and 1.
function softmax(resultArray) {
  // Get the largest value in the array.
  const largestNumber = Math.max(...resultArray);
  // Apply the exponential function to each result item subtracted by the largest number, using reduction to get the
  // previous result number and the current number to sum all the exponentials results.
  const sumOfExp = resultArray 
    .map(resultItem => Math.exp(resultItem - largestNumber)) 
    .reduce((prevNumber, currentNumber) => prevNumber + currentNumber);

  // Normalize the resultArray by dividing by the sum of all exponentials.
  // This normalization ensures that the sum of the components of the output vector is 1.
  return resultArray.map((resultValue, index) => {
    return Math.exp(resultValue - largestNumber) / sumOfExp
  });
}

function imagenetClassesTopK(classProbabilities, k = 5) { 
  const probs = _.isTypedArray(classProbabilities)
    ? Array.prototype.slice.call(classProbabilities)
    : classProbabilities;

  const sorted = _.reverse(
    _.sortBy(
      probs.map((prob, index) => [prob, index]),
      probIndex => probIndex[0]
    )
  );

  const topK = _.take(sorted, k).map(probIndex => {
    const iClass = imagenetClasses[probIndex[1]]
    return {
      id: iClass[0],
      index: parseInt(probIndex[1].toString(), 10),
      name: iClass[1].replace(/_/g, " "),
      probability: probIndex[0]
    }
  });
  return topK;
}
  1. Dodano już wszystkie skrypty potrzebne do uruchomienia klasyfikacji obrazów za pomocą WebNN w podstawowej aplikacji internetowej. Za pomocą rozszerzenia Live Server dla programu VS Code możesz teraz uruchomić podstawową stronę internetową bezpośrednio w aplikacji, aby samodzielnie zobaczyć wyniki klasyfikacji.
  • Last updated on