Das könnte dich auch interessieren: Wie man in Windows die GPU für TensorFlow aktiviert

Sprache und Umgebung

Tensorflow.js wurde speziell für JavaScript entwickelt, was bedeutet, dass sich Modelle direkt in JavaScript-Code implementieren lassen. Dies ermöglicht die nahtlose Integration in Webanwendungen und die Ausführung der Modelle im Browser ohne zusätzliche Serverinfrastruktur.

Tensorflow Python bietet eine umfassende Python-Bibliothek für maschinelles Lernen. Python ist eine weit verbreitete Programmiersprache im Bereich des maschinellen Lernens und bietet eine Vielzahl von Bibliotheken und Frameworks, die die Entwicklung und den Einsatz von Modellen erleichtern.

Zielplattform

Eine der größten Stärken von Tensorflow.js ist die Möglichkeit, Modelle direkt im Browser auszuführen. Dies ermöglicht es Entwicklern, interaktive Webanwendungen mit maschinellem Lernen zu erstellen, ohne dass der Nutzer zusätzliche Software installieren oder externe Serveranfragen senden muss.

Tensorflow Python hingegen ermöglicht die Entwicklung und Ausführung von Modellen auf verschiedenen Plattformen, einschließlich Desktop-Computern, Servern und mobilen Geräten. Es bietet eine breite Palette an Funktionen und unterstützt fortschrittliche Techniken wie das Trainieren von Modellen auf GPUs oder TPUs. TPU steht für „Tensor Processing Unit“. Das sind anwendungsspezifische Chips um Anwendungen im Rahmen von maschinellem Lernen zu beschleunigen

Community

Wenn man ehrlich ist die Tensorflow.js Community einfach zu klein. Bei vielen Fragen hat man das Gefühl man leistet hier „Pioniersarbeit“, was gerade für Anfänger nicht zu empfehlen ist. Zur Verdeutlichung: Es gibt 80 Mal mehr StackOverflow Fragen zu TensorFlow als zu TensorFlow.js. Je nach Anwendungsfall existieren aber mittlerweile auch für TensorFlow.js eine Reihe von Ressourcen, Tutorials und Beispielen, die bei der Entwicklung mit Tensorflow.js helfen können. Da JavaScript eine weit verbreitete Sprache ist, kann man auch auf eine große Menge an generellen Webentwicklungsressourcen zurückgreifen, die bei der Arbeit mit Tensorflow.js helfen können.

Tensorflow Python dagegen profitiert von einer großen und aktiven Community, die regelmäßig neue Modelle, Techniken und Ressourcen entwickelt und veröffentlicht. Es gibt eine Vielzahl von Tutorials, Foren und Open-Source-Projekten, die Ihnen helfen können, Ihre maschinellen Lernprojekte voranzutreiben. Die Python-Community ist für ihre Unterstützung und Zusammenarbeit bekannt, was den Einstieg in Tensorflow Python erleichtern kann.

Bibliotheken

In vielen Fällen und speziell bei meinem NLP Projekt ein K.O Kriterium für Tensorflow.js waren die Bibliotheken. Tensorflow.js hat im Vergleich zu Tensorflow Python viel weniger Bibliotheken. Das liegt aus meiner Sicht an folgenden 3 Punkten:

1. Entwicklungsstand: Tensorflow Python existiert seit mehreren Jahren und hat eine lange Entwicklungszeit hinter sich. Während dieser Zeit wurden zahlreiche Erweiterungen, Module und zusätzliche Bibliotheken entwickelt, die speziell für Tensorflow Python entwickelt wurden. Tensorflow.js hingegen ist eine vergleichsweise neuere Technologie und befindet sich möglicherweise noch in einem früheren Entwicklungsstadium. Daher hat Tensorflow.js möglicherweise weniger Bibliotheken und Erweiterungen, die speziell für diese Plattform entwickelt wurden.

2. Zielplattform: Tensorflow Python richtet sich an eine breite Palette von Plattformen, einschließlich Desktop-Computern, Servern und mobilen Geräten. Daher gibt es eine Vielzahl von spezialisierten Bibliotheken und Erweiterungen für verschiedene Anwendungsfälle und Hardwarekonfigurationen. Tensorflow.js hingegen zielt darauf ab, Modelle direkt im Browser auszuführen. Daher sind die Funktionen und Bibliotheken von Tensorflow.js auf die Anforderungen von Webanwendungen und die begrenzte Ressourcenverfügbarkeit im Browser optimiert.

3. Kompatibilität: Tensorflow.js basiert auf JavaScript, einer Sprache, die in erster Linie für Webentwicklung verwendet wird. Obwohl JavaScript eine große Entwicklergemeinschaft und viele bestehende Bibliotheken und Frameworks hat, sind nicht alle davon direkt mit Tensorflow.js kompatibel. Daher kann es sein, dass nicht alle verfügbaren Bibliotheken und Erweiterungen für Tensorflow Python auch für Tensorflow.js zur Verfügung stehen.

Es ist jedoch wichtig anzumerken, dass Tensorflow.js stetig weiterentwickelt wird und die Bibliothek und die verfügbaren Erweiterungen mit der Zeit wachsen können. Die Community rund um Tensorflow.js arbeitet daran, das Ökosystem zu erweitern und neue Bibliotheken sowie Tools bereitzustellen, um den Funktionsumfang zu verbessern und die Möglichkeiten von Tensorflow.js zu erweitern.

Plattformunterstützung

TensorFlow, das in C++ geschrieben wurde, ist eine plattformübergreifende Bibliothek, die auf verschiedenen Betriebssystemen wie Windows, macOS und Linux unterstützt wird. Es kann sowohl für die Entwicklung und Ausführung von Modellen auf Servern als auch auf Desktop-Computern verwendet werden.

TensorFlow unterstützt daher eine breitere Palette von Plattformen als TensorFlow.js, da TensorFlow.js hauptsächlich auf JavaScript-Umgebungen wie dem Browser und Node.js ausgerichtet ist.

Trainieren großer Modelle

TensorFlow kann sehr große Modelle trainieren und verarbeiten, während TensorFlow.js aufgrund der Leistungseinschränkungen von JavaScript-Engines auf kleinere Modelle beschränkt ist.

JavaScript-Engines sind im Vergleich zu spezialisierten Machine-Learning-Frameworks und Hardwarebeschleunigern wie GPUs oder TPUs weniger leistungsstark. Dies bedeutet, dass TensorFlow.js aufgrund der begrenzten Rechenleistung und des begrenzten Speichers von JavaScript-Engines in der Regel für kleinere Modelle geeignet ist.

Daher wird TensorFlow für Projekte empfohlen, bei denen große Modelle trainiert oder komplexe Berechnungen durchgeführt werden müssen, während TensorFlow.js besser für Anwendungen geeignet ist, die kleinere Modelle verwenden und in Webbrowsern oder JavaScript-Umgebungen ausgeführt werden sollen.

Warum TensorFlow.js clientseitig im Browser nutzen?

Da wäre das Thema Geschwindigkeit. Da man keine Daten an einen entfernten Server senden muss, erfolgt die Klassifizierung schneller. Zudem hat man direkten Zugriff auf die Sensoren wie Kamera, Mikrofon, GPS usw.

Außerdem ist in vielen Ländern der Datenschutz ein wichtiger Punkt. Man kann Daten auf dem eigenen Rechner trainieren und klassifizieren, ohne sie an einen externen Webserver senden zu müssen. Das kann erforderlich sein, um Datenschutzgesetze wie die DSGVO einzuhalten oder wenn man die Daten nicht an Dritte weitergeben möchte.

Mit einem Klick kann jeder auf der Welt über einen Link auf die Anwendung zugreifen und sie nutzen ohne, dass ein komplexes Setup mit Servern und spezieller Hardware wie Grafikkarten erforderlich ist.

Abschließend sollte man bei ML auch die Kosten im Blick behalten. Man muss lediglich für das hosten des Clients zahlen. Das ist deutlich günstiger als die dauerhafte Aufrechterhaltung eines eigenen Servers.

Fazit Tensorflow.js oder Tensorflow nutzen?

Insgesamt kann man die Frage Tensorflow.js oder Tensorflow vereinfacht dadurch beantworten, dass Tensorflow mit Python aufgrund seiner breiten Akzeptanz und großen Community nahezu IMMER die bessere Wahl ist. Nichtsdestotrotz gewinnt Tensorflow.js zunehmend an Bedeutung und wird überwiegend von Entwicklern genutzt, die Webanwendungen mit maschinellem Lernen clientseitig entwickeln möchten.

Das heißt, wenn du Anwendungen erstellen möchtest, die im Webbrowser laufen sollen, ist TensorFlow.js eigentlich die bessere Wahl. Wenn du jedoch Anwendungen erstellen möchtest, die auf einem Server oder einem Desktop-Computer laufen sollen, ist TensorFlow die bessere Option. Außerdem ist die Python Version viel besser geeignet, wenn du mit leistungsstarken Geräten wie GPUs arbeiten möchtest.

The post Tensorflow.js oder Tensorflow nutzen? appeared first on Nerd Corner.

Auch sollte der Fokus stehts auf clean Code legen und dieser ordentlich dokumentiert sein, besonders wenn ein Projekt größer wird zahlt sich ordentlich dokumentierte Arbeit aus. Um beispielsweise REST Endpunkte zu dokumentieren empfiehlt es sich Swagger zu benutzen. Die Swagger API Dokumentation bietet eine Übersicht über alle Endpunkte und sogar die Möglichkeit mit diesen zu interagieren.

Das könnte Sie auch interessieren: Angular Form SVG mit clickbaren Elementen

Liste der Komponenten

• Entwicklungsumgebung (z.B. VS Code)
• Node.js

Dokumentation mit Swagger

Obwohl Swagger recht bekannt ist, konnte ich keine detaillierte Anleitung für die Implementation finden. Ich möchte daher 2 Wege zur Implementierung von Swagger in einen bestehenden Node Server erklären. Die erste Möglichkeit besteht darin direkt zu jedem Endpunkt Swagger Parameter hinzuzufügen. Das ist wohl die schnellere Variante, kann allerdings abhängig von der Anzahl der Endpunkte unübersichtlich werden. In der zweiten Variante wird eine „swagger.json“ Datei erstellt, die die  Parameter der Endpunkte zusammenfasst.

Um Swagger nutzen zu können wird folgende Bibliothek bzw. deren Typerweiterung genutzt:

npm install --save  swagger-ui-express
npm install --save-dev @types/swagger-ui-express

Swagger erstellt eine Dokumentation der Endpunkte:

Diese können geöffnet werden und man sieht einen beispielhaften Request und einen beispielhaften Response:

Über den Button „Try it out“ kann direkt mit dem Endpunkt interagiert werden.

Swagger API Dokumentation mit Parametern

Diese Variante empfiehlt sich eher für kleinere Projekte. Zunächst müssen diese beiden Swagger Bibliotheken in das Projekt eingebunden werden:

npm install --save-dev @types/swagger-jsdoc 
npm install --save swagger-jsdoc

Die Bibliotheken werden in app.ts bzw. für nicht Typescript Nutzer app.js konfiguriert. Aufgrund der hier festgelegten Konfiguration befindet sich die Dokumentation unter „/api-docs“:

import express from "express";
import bodyParser from "body-parser";
import exampleRoutes from "./routes/example-route";
import swaggerJSDoc from "swagger-jsdoc";
import swaggerUi from "swagger-ui-express";

const app = express();

const options = {
  definition: {
    openapi: "3.0.1",
    info: {
      title: "REST API for Swagger Documentation",
      version: "1.0.0",
    },
    schemes: ["http", "https"],
    servers: [{ url: "http://localhost:3000/" }],
  },
  apis: [
    `${__dirname}/routes/example-route.ts`,
    "./dist/routes/example-route.js",
  ],
};

const swaggerSpec = swaggerJSDoc(options);

app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerSpec));
app.use(bodyParser.json());
app.use(exampleRoutes);

app.listen(3000);

Der Endpunkt wird mit den Parametern folgendermaßen beschrieben:

import { Router } from "express";
import { exampleFunction } from "../controller/example";

const router = Router();

/**
 * @swagger
 * /example:
 *      post:
 *          summary: Send the text to the server
 *          tags:
 *              - ExampleEndpoints
 *          description: Send a message to the server and get a response added to the original text.
 *          requestBody:
 *              required: true
 *              content:
 *                  application/json:
 *                      schema:
 *                          type: object
 *                          properties:
 *                              responseText:
 *                                  type: string
 *                                  example: This is some example string! This is an endpoint
 *          responses:
 *              201:
 *                  description: Success
 *                  content:
 *                      application/json:
 *                          schema:
 *                              type: object
 *                              properties:
 *                                  text:
 *                                      type: string
 *                                      example: This is some example string!
 *              404:
 *                  description: Not found
 *              500:
 *                  description: Internal server error
 */
router.post("/example", exampleFunction);

export default router;

Swagger API Dokumentation mit swagger.json

Um eine bessere Übersicht zu haben und um die Dokumentation nicht mit dem eigentlichen Code zu vermischen empfiehlt sich die Nutzung einer, oder gar mehrerer json Dateien. Bei der Nutzung von TypeScript muss die Swagger.json Datei in die rootDirectory:

Auch hier wirdzunächst die Konfiguration in app.ts bzw. für nicht Typescript Nutzer in app.js festgelegt. Hier wird ebenfalls der Domainpfad „/api-docs“ für die Dokumentation gewählt:

import express from "express";
import bodyParser from "body-parser";
import exampleRoutes from "./routes/example-route";
import swaggerUi from "swagger-ui-express";

import * as swaggerDocument from "./swagger.json";

const app = express();

app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerDocument));

app.use(bodyParser.json());

app.use(exampleRoutes);

app.listen(3000);

Wichtiger Hinweis: Um JSON Dateien in ein Typescript Projekt zu importieren muss dies in der tsconfig.json erlaubt werden. Außerdem muss die JSON Datei sich in der root directory befinden:

{
  "compilerOptions": {
    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
    "module": "commonjs" /* Specify what module code is generated. */,
    "rootDir": "./src" /* Specify the root folder within your source files. */,
    "moduleResolution": "node" /* Specify how TypeScript looks up a file from a given module specifier. */,
    "resolveJsonModule": true /* Enable importing .json files. */,
    "outDir": "./dist" /* Specify an output folder for all emitted files. */,
    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
    "strict": true /* Enable all strict type-checking options. */,
    "skipLibCheck": true /* Skip type checking all .d.ts files. */
  }
}

Die vorherige Swagger Dokumentation mit Parametern würde somit in der swagger.json folgendermaßen aussehen:

{
  "openapi": "3.0.1",
  "info": {
    "title": "REST API for Swagger Documentation",
    "version": "1.0.0"
  },
  "schemes": ["http"],
  "servers": [{ "url": "http://localhost:3000/" }],
  "paths": {
    "/example": {
      "post": {
        "tags": ["ExampleEndpoints"],
        "summary": "Send a text to the server",
        "description": "Send a message to the server and get a response added to the original text.",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ExampleSchemaHeader"
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ExampleSchemaBody"
                }
              }
            }
          },
          "404": { "description": "Not found" },
          "500": { "description": "Internal server error" }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "ExampleSchemaBody": {
        "properties": {
          "responseText": {
            "type": "string",
            "example": "This is some example string! This is an endpoint"
          }
        }
      },
      "ExampleSchemaHeader": {
        "required": ["text"],
        "properties": {
          "text": {
            "type": "string",
            "example": "This is some example string!"
          }
        }
      }
    }
  }
}

Dateien zum Herunterladen

• Github Beispielprojekt für swagger Parameter
• Github Beispielprojekt für swagger.json

The post Swagger Api Doku zu Node Server hinzufügen appeared first on Nerd Corner.