Apprentissage profond avec PHP et PyTorch

L'apprentissage profond est une branche importante dans le domaine de l'intelligence artificielle et a reçu de plus en plus d'attention et d'attention ces dernières années. Afin de pouvoir mener des recherches et des applications en matière d'apprentissage profond, il est souvent nécessaire d'utiliser certains cadres d'apprentissage profond pour y parvenir. Dans cet article, nous présenterons comment utiliser PHP et PyTorch pour le deep learning.

1. Qu'est-ce que PyTorch

PyTorch est un framework d'apprentissage automatique open source développé par Facebook, qui peut nous aider à créer et former rapidement des modèles d'apprentissage en profondeur. La caractéristique de PyTorch est l'utilisation de graphiques de calcul dynamiques pour réaliser la formation et l'optimisation de modèles. Cette méthode nous permet de créer des modèles d'apprentissage en profondeur complexes de manière plus flexible. Dans le même temps, PyTorch fournit également une multitude de modèles et d'algorithmes pré-entraînés, qui peuvent nous aider à mener plus facilement des recherches et des applications d'apprentissage en profondeur.

2. Pourquoi utiliser PHP et PyTorch

Comparé à d'autres langages de programmation, Python est un langage très populaire et apprécié dans le domaine du deep learning. Python dispose d'une multitude de bibliothèques tierces et d'outils open source qui nous facilitent l'utilisation et le déploiement de modèles d'apprentissage en profondeur. Pendant ce temps, PHP est un autre langage de programmation largement utilisé et très populaire pour le développement d’applications Web et de sites Web. L'utilisation de PHP et de PyTorch peut nous aider à appliquer des modèles d'apprentissage profond aux applications Web et aux sites Web pour réaliser diverses fonctions intelligentes. Par exemple, nous pouvons intégrer le modèle d'apprentissage profond dans une application Web pour implémenter des fonctions telles que la reconnaissance faciale et la classification d'images, et interagir avec le front-end via PHP pour offrir aux utilisateurs une meilleure expérience.

3. Utilisez PHP et PyTorch pour le deep learning

Ci-dessous, nous présenterons comment utiliser PHP et PyTorch pour le deep learning.

1. Install PyTorch

Avant de commencer, nous devons d'abord installer la bibliothèque PyTorch. Vous pouvez vous référer à la documentation officielle de PyTorch pour l'installation : https://pytorch.org/get-started/locally/.

2. Écrire un script Python

Ensuite, nous écrirons un simple script Python pour créer et entraîner un modèle d'apprentissage en profondeur. Ce modèle est utilisé pour classer les chiffres manuscrits.

Tout d'abord, nous devons importer la bibliothèque PyTorch et les autres bibliothèques nécessaires :

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

Ensuite, définir un modèle de réseau neuronal :

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)

Ce neuronal réseau Le modèle comprend deux couches convolutives et deux couches entièrement connectées. Parmi eux, la couche convolutive est utilisée pour extraire les caractéristiques de l'image d'entrée, et la couche entièrement connectée est utilisée pour produire les résultats de classification. Lors de la propagation vers l'avant, nous utilisons ReLU comme fonction d'activation et utilisons le pooling et l'abandon maximum pour aider le modèle à mieux se généraliser.

Ensuite, nous devons définir certains hyperparamètres et paramètres d'entraînement :

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

Dans cet exemple, nous utilisons un simple algorithme de descente de gradient stochastique (SGD) par lots pour optimiser le modèle. À chaque époque, nous divisons les données de formation en lots et formons et optimisons chaque lot. Pendant le processus de formation, nous calculons et enregistrons la perte et la précision sur les ensembles de formation et de test.

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))

3. Utiliser PHP pour appeler un script Python

Maintenant que nous avons terminé la création et la formation d'un modèle simple d'apprentissage en profondeur, nous allons ensuite Présentez comment utiliser PHP pour appeler ce script Python et utiliser le modèle formé pour des applications pratiques.

Nous pouvons utiliser la fonction exec de PHP pour appeler le script Python, par exemple :

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

Cette commande exécutera le script train.py et stockera les résultats de sortie dans $output_array tableau . Si le processus de formation prend du temps, nous pouvons utiliser la fonction flush de PHP pour obtenir une sortie en temps réel, par exemple :

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

De cette façon, nous pouvons intégrer le modèle d'apprentissage profond dans notre application PHP, et utilisez-le pour fournir diverses fonctions intelligentes.

4. Résumé

Cet article présente comment utiliser PHP et PyTorch pour l'apprentissage en profondeur, notamment la création et la formation d'un modèle simple de classification des chiffres manuscrits, et comment intégrer ce modèle dans Dans une application PHP. De cette façon, nous pouvons appliquer des modèles d'apprentissage profond à diverses applications Web et sites Web pour fournir des fonctions et des services plus intelligents.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!