Die KI-Ära von JS ist da!

JS-Torch-Einführung

JS-Torch ist eine Deep-Learning-JavaScript-Bibliothek, deren Syntax PyTorch sehr ähnlich ist. Es enthält ein voll funktionsfähiges Tensorobjekt (kann mit verfolgten Farbverläufen verwendet werden), Deep-Learning-Ebenen und -Funktionen sowie eine automatische Differenzierungs-Engine. JS-Torch eignet sich für die Deep-Learning-Forschung in JavaScript und bietet viele praktische Tools und Funktionen zur Beschleunigung der Deep-Learning-Entwicklung.

Bilder

PyTorch ist ein Open-Source-Deep-Learning-Framework, das vom Forschungsteam von Meta entwickelt und gepflegt wird. Es bietet einen umfangreichen Satz an Tools und Bibliotheken zum Erstellen und Trainieren neuronaler Netzwerkmodelle. Das Designkonzept von PyTorch ist Einfachheit, Flexibilität und Benutzerfreundlichkeit. Die Funktion für dynamische Berechnungsdiagramme macht die Modellkonstruktion intuitiver und flexibler und verbessert gleichzeitig die Effizienz der Modellkonstruktion und des Debuggens. Die dynamische Berechnungsdiagrammfunktion von PyTorch macht die Modellkonstruktion außerdem intuitiver und einfacher zu debuggen und zu optimieren. Darüber hinaus verfügt PyTorch über eine gute Skalierbarkeit und Betriebseffizienz, was es im Bereich Deep Learning beliebt und anwendbar macht.

Sie können js-pytorch über npm oder pnpm installieren:

npm install js-pytorchpnpm add js-pytorch

oder erleben Sie die Demo[3] von js-pytorch online:

Bilder

https://eduardoleao052.github. io/js-torch/assets/demo/demo.html

Von JS-Torch unterstützte Funktionen

Derzeit unterstützt JS-Torch bereits Tensoroperationen wie Addieren, Subtrahieren, Multiplizieren, Dividieren usw. Es unterstützt auch lineare, MultiHeadSelfAttention, häufig verwendete Deep-Learning-Schichten wie ReLU und LayerNorm.

Tensoroperationen

• Addieren
• Subtrahieren
• Multiplizieren
• Dividieren
• Matrixmultiplizieren
• Potenzial
• Quadratwurzel
• Potenzieren
• Log
• S ähm
• Mittelwert
• Varianz
• Transponieren
• At
• MaskedFill
• Reshape

Deep Learning Layers

• nn.Linear
• nn.MultiHeadSelfAttention
• nn.FullyConnected
• nn.Block
• nn.Embedding
• nn. PositionalEmbedding
• nn.ReLU
• nn .Softmax
• nn.Dropout
• nn.LayerNorm
• nn.CrossEntropyLoss

JS-Torch-Nutzungsbeispiel

Simple Autograd

import { torch } from "js-pytorch";// Instantiate Tensors:let x = torch.randn([8, 4, 5]);let w = torch.randn([8, 5, 4], (requires_grad = true));let b = torch.tensor([0.2, 0.5, 0.1, 0.0], (requires_grad = true));// Make calculations:let out = torch.matmul(x, w);out = torch.add(out, b);// Compute gradients on whole graph:out.backward();// Get gradients from specific Tensors:console.log(w.grad);console.log(b.grad);

Complex Autograd. (Transformer)

import { torch } from "js-pytorch";const nn = torch.nn;class Transformer extends nn.Module {constructor(vocab_size, hidden_size, n_timesteps, n_heads, p) {super();// Instantiate Transformer's Layers:this.embed = new nn.Embedding(vocab_size, hidden_size);this.pos_embed = new nn.PositionalEmbedding(n_timesteps, hidden_size);this.b1 = new nn.Block(hidden_size,hidden_size,n_heads,n_timesteps,(dropout_p = p));this.b2 = new nn.Block(hidden_size,hidden_size,n_heads,n_timesteps,(dropout_p = p));this.ln = new nn.LayerNorm(hidden_size);this.linear = new nn.Linear(hidden_size, vocab_size);}forward(x) {let z;z = torch.add(this.embed.forward(x), this.pos_embed.forward(x));z = this.b1.forward(z);z = this.b2.forward(z);z = this.ln.forward(z);z = this.linear.forward(z);return z;}}// Instantiate your custom nn.Module:const model = new Transformer(vocab_size,hidden_size,n_timesteps,n_heads,dropout_p);// Define loss function and optimizer:const loss_func = new nn.CrossEntropyLoss();const optimizer = new optim.Adam(model.parameters(), (lr = 5e-3), (reg = 0));// Instantiate sample input and output:let x = torch.randint(0, vocab_size, [batch_size, n_timesteps, 1]);let y = torch.randint(0, vocab_size, [batch_size, n_timesteps]);let loss;// Training Loop:for (let i = 0; i < 40; i++) {// Forward pass through the Transformer:let z = model.forward(x);// Get loss:loss = loss_func.forward(z, y);// Backpropagate the loss using torch.tensor's backward() method:loss.backward();// Update the weights:optimizer.step();// Reset the gradients to zero after each training step:optimizer.zero_grad();}

Nachdem ich JS-Torch hatte, Der Tag der Ausführung von KI-Anwendungen auf Node.js, Deno und anderen JS Runtime rückt näher. Damit JS-Torch populär wird, muss es natürlich auch ein sehr wichtiges Problem lösen, nämlich die GPU-Beschleunigung. Es gibt bereits entsprechende Diskussionen. Wenn Sie interessiert sind, können Sie weitere verwandte Inhalte lesen: GPU-Unterstützung[4].

Referenzen

[1]JS-Torch: https://github.com/eduardoleao052/js-torch

[2]PyTorch: https://pytorch.org/

[3]Demo: https: / /eduardoleao052.github.io/js-torch/assets/demo/demo.html

[4]GPU-Unterstützung: https://github.com/eduardoleao052/js-torch/issues/1