Deep Learning mit PHP und PyTorch

Deep Learning ist ein wichtiger Zweig im Bereich der künstlichen Intelligenz und hat in den letzten Jahren immer mehr Aufmerksamkeit und Beachtung gefunden. Um Deep-Learning-Forschung und -Anwendungen durchführen zu können, ist es oft notwendig, einige Deep-Learning-Frameworks zu verwenden, um dies zu erreichen. In diesem Artikel stellen wir vor, wie man PHP und PyTorch für Deep Learning verwendet.

1. Was ist PyTorch? PyTorch ist ein von Facebook entwickeltes Open-Source-Framework für maschinelles Lernen, mit dem wir schnell Deep-Learning-Modelle erstellen und trainieren können. Das Merkmal von PyTorch ist die Verwendung dynamischer Rechendiagramme zur Modellschulung und -optimierung. Mit dieser Methode können wir komplexe Deep-Learning-Modelle flexibler erstellen. Gleichzeitig bietet PyTorch auch eine Fülle vorab trainierter Modelle und Algorithmen, die uns dabei helfen können, Deep-Learning-Forschung und -Anwendungen bequemer durchzuführen.

2. Warum PHP und PyTorch verwenden? Im Vergleich zu anderen Programmiersprachen ist Python eine sehr beliebte und beliebte Sprache im Bereich Deep Learning. Python verfügt über eine Fülle von Bibliotheken und Open-Source-Tools von Drittanbietern, die uns die Verwendung und Bereitstellung von Deep-Learning-Modellen erleichtern. Mittlerweile ist PHP eine weitere weit verbreitete Programmiersprache, die für die Entwicklung von Webanwendungen und Websites sehr beliebt ist. Die Verwendung von PHP und PyTorch kann uns dabei helfen, Deep-Learning-Modelle auf Webanwendungen und Websites anzuwenden, um verschiedene intelligente Funktionen zu erreichen. Beispielsweise können wir das Deep-Learning-Modell in eine Webanwendung einbetten, um Funktionen wie Gesichtserkennung und Bildklassifizierung zu implementieren und über PHP mit dem Frontend zu interagieren, um Benutzern ein besseres Erlebnis zu bieten.

3. Verwenden Sie PHP und PyTorch für Deep Learning.

Im Folgenden stellen wir vor, wie Sie PHP und PyTorch für Deep Learning verwenden.

PyTorch installieren

Bevor wir beginnen, müssen wir zuerst die PyTorch-Bibliothek installieren. Informationen zur Installation finden Sie in der offiziellen Dokumentation von PyTorch: https://pytorch.org/get-started/locally/.

Ein Python-Skript schreiben

Als nächstes schreiben wir ein einfaches Python-Skript, um ein Deep-Learning-Modell zu erstellen und zu trainieren. Dieses Modell wird zur Klassifizierung handschriftlicher Ziffern verwendet.
2. Zuerst müssen wir die PyTorch-Bibliothek und andere notwendige Bibliotheken importieren:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

Dann definieren wir ein neuronales Netzwerkmodell:

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.dropout = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = nn.functional.relu(nn.functional.max_pool2d(self.conv1(x), 2))
        x = nn.functional.relu(nn.functional.max_pool2d(self.dropout(self.conv2(x)), 2))
        x = x.view(-1, 320)
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.dropout(x, training=self.training)
        x = self.fc2(x)
        return nn.functional.log_softmax(x, dim=1)

Dieses neuronale Netzwerkmodell umfasst zwei Faltungsschichten und zwei vollständig verbundene Schichten. Unter diesen wird die Faltungsschicht zum Extrahieren der Merkmale des Eingabebilds und die vollständig verbundene Schicht zum Ausgeben der Klassifizierungsergebnisse verwendet. Während der Vorwärtsausbreitung verwenden wir ReLU als Aktivierungsfunktion und verwenden maximales Pooling und Dropout, um die Generalisierung des Modells zu verbessern.

Als nächstes müssen wir einige Hyperparameter und Trainingsparameter definieren:

batch_size = 64
learning_rate = 0.01
momentum = 0.5
epochs = 10

In diesem Beispiel verwenden wir einen einfachen Batch-Algorithmus für den stochastischen Gradientenabstieg (SGD), um das Modell zu optimieren. In jeder Epoche teilen wir die Trainingsdaten in Stapel auf und trainieren und optimieren jeden Stapel. Während des Trainingsprozesses berechnen und zeichnen wir den Verlust und die Genauigkeit der Trainings- und Testsätze auf.

train_loader = DataLoader(
    datasets.MNIST('./data', train=True, download=True, transform=transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])),
    batch_size=batch_size, shuffle=True)
test_loader = DataLoader(
    datasets.MNIST('./data', train=False, transform=transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])),
    batch_size=batch_size, shuffle=True)

model = Net()
optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)

train_loss_history = []
train_acc_history = []
test_loss_history = []
test_acc_history = []

for epoch in range(1, epochs + 1):
    # Train
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = nn.functional.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 10 == 0:
            print('Epoch [{}/{}], Train Batch: [{}/{}], Train Loss: {:.6f}'.format(epoch, epochs, batch_idx, len(train_loader), loss.item()))
    # Evaluate
    model.eval()
    train_loss = 0
    train_correct = 0
    test_loss = 0
    test_correct = 0
    with torch.no_grad():
        for data, target in train_loader:
            output = model(data)
            train_loss += nn.functional.nll_loss(output, target, reduction='sum').item()
            pred = output.argmax(dim=1, keepdim=True)
            train_correct += pred.eq(target.view_as(pred)).sum().item()
        train_loss /= len(train_loader.dataset)
        train_acc = 100. * train_correct / len(train_loader.dataset)
        train_loss_history.append(train_loss)
        train_acc_history.append(train_acc)
        for data, target in test_loader:
            output = model(data)
            test_loss += nn.functional.nll_loss(output, target, reduction='sum').item()
            pred = output.argmax(dim=1, keepdim=True)
            test_correct += pred.eq(target.view_as(pred)).sum().item()
        test_loss /= len(test_loader.dataset)
        test_acc = 100. * test_correct / len(test_loader.dataset)
        test_loss_history.append(test_loss)
        test_acc_history.append(test_acc)
        print('Epoch {}: Train Loss: {:.6f}, Train Acc: {:.2f}%, Test Loss: {:.6f}, Test Acc: {:.2f}%'.format(epoch, train_loss, train_acc, test_loss, test_acc))

PHP zum Aufrufen eines Python-Skripts verwenden

Da wir nun die Erstellung und das Training eines einfachen Deep-Learning-Modells abgeschlossen haben, werden wir als Nächstes vorstellen, wie man PHP zum Aufrufen dieses Python-Skripts verwendet und das trainierte Modell in der Praxis verwendet Anwendung.
3. Wir können die Exec-Funktion von PHP verwenden, um das Python-Skript aufzurufen, zum Beispiel:

$output = exec("python train.py 2>&1", $output_array);

Dieser Befehl führt das train.py-Skript aus und speichert die Ausgabeergebnisse im Array $output_array. Wenn der Trainingsprozess zeitaufwändig ist, können wir die Flush-Funktion von PHP verwenden, um eine Echtzeitausgabe zu erzielen, zum Beispiel:

echo '
';
$output = exec("python train.py 2>&1", $output_array);
foreach ($output_array as $o) {
    echo $o . '
';
    flush();
}
echo '
';

Auf diese Weise können wir das Deep-Learning-Modell in unsere PHP-Anwendung integrieren und es zur Bereitstellung verschiedener intelligenter Funktionen verwenden Funktionen.

4. Zusammenfassung

In diesem Artikel wird erläutert, wie Sie PHP und PyTorch für Deep Learning verwenden, einschließlich der Erstellung und des Trainings eines einfachen handschriftlichen Ziffernklassifizierungsmodells, und wie Sie dieses Modell in eine PHP-Anwendung einbetten. Auf diese Weise können wir Deep-Learning-Modelle auf verschiedene Webanwendungen und Websites anwenden, um intelligentere Funktionen und Dienste bereitzustellen.

Das obige ist der detaillierte Inhalt vonDeep Learning mit PHP und PyTorch. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!