Pembelajaran Mendalam dengan PHP dan PyTorch

Pembelajaran mendalam merupakan satu cabang penting dalam bidang kecerdasan buatan dan semakin mendapat perhatian sejak beberapa tahun kebelakangan ini. Untuk dapat menjalankan penyelidikan dan aplikasi pembelajaran mendalam, selalunya perlu menggunakan beberapa rangka kerja pembelajaran mendalam untuk membantu melaksanakannya. Dalam artikel ini, kami akan memperkenalkan cara menggunakan PHP dan PyTorch untuk pembelajaran mendalam.

1. Apakah itu PyTorch

PyTorch ialah rangka kerja pembelajaran mesin sumber terbuka yang dibangunkan oleh Facebook, yang boleh membantu kami mencipta dan melatih model pembelajaran mendalam dengan cepat. Ciri PyTorch ialah penggunaan graf pengkomputeran dinamik untuk mencapai latihan model dan pengoptimuman Kaedah ini membolehkan kami mencipta model pembelajaran mendalam yang kompleks dengan lebih fleksibel. Pada masa yang sama, PyTorch juga menyediakan pelbagai model dan algoritma pra-latihan, yang boleh membantu kami menjalankan penyelidikan dan aplikasi pembelajaran mendalam dengan lebih mudah.

2. Mengapa menggunakan PHP dan PyTorch

Berbanding dengan bahasa pengaturcaraan lain, Python ialah bahasa yang sangat popular dan popular dalam bidang pembelajaran mendalam. Python mempunyai banyak perpustakaan pihak ketiga dan alatan sumber terbuka yang memudahkan kami menggunakan dan menggunakan model pembelajaran mendalam. Sementara itu, PHP adalah satu lagi bahasa pengaturcaraan yang digunakan secara meluas yang sangat popular untuk aplikasi web dan pembangunan laman web. Menggunakan PHP dan PyTorch boleh membantu kami menggunakan model pembelajaran mendalam pada aplikasi web dan tapak web untuk mencapai pelbagai fungsi pintar. Sebagai contoh, kami boleh membenamkan model pembelajaran mendalam ke dalam aplikasi web untuk melaksanakan fungsi seperti pengecaman muka dan klasifikasi imej, dan berinteraksi dengan bahagian hadapan melalui PHP untuk memberikan pengguna pengalaman yang lebih baik.

3. Gunakan PHP dan PyTorch untuk pembelajaran mendalam

Di bawah, kami akan memperkenalkan cara menggunakan PHP dan PyTorch untuk pembelajaran mendalam.

1. Pasang PyTorch

Sebelum kita mula, kita perlu memasang perpustakaan PyTorch. Anda boleh merujuk kepada dokumentasi rasmi PyTorch untuk pemasangan: https://pytorch.org/get-started/locally/.

2. Menulis skrip Python

Seterusnya, kami akan menulis skrip Python mudah untuk mencipta dan melatih model pembelajaran mendalam. Model ini digunakan untuk mengelaskan digit tulisan tangan.

Pertama, kita perlu mengimport perpustakaan PyTorch dan perpustakaan lain yang diperlukan:

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

Kemudian, tentukan model rangkaian saraf:

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)

Model rangkaian saraf ini termasuk dua lapisan konvolusi dan dua lapisan bersambung sepenuhnya. Antaranya, lapisan konvolusi digunakan untuk mengekstrak ciri imej input, dan lapisan bersambung sepenuhnya digunakan untuk mengeluarkan hasil pengelasan. Semasa penyebaran ke hadapan, kami menggunakan ReLU sebagai fungsi pengaktifan, dan menggunakan pengumpulan dan keciciran maksimum untuk membantu model membuat generalisasi dengan lebih baik.

Seterusnya, kita perlu menentukan beberapa hiperparameter dan parameter latihan:

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

Dalam contoh ini, kami menggunakan algoritma keturunan kecerunan stokastik (SGD) kelompok mudah untuk mengoptimumkan model. Dalam setiap zaman, kami membahagikan data latihan kepada kelompok dan melatih serta mengoptimumkan setiap kelompok. Semasa proses latihan, kami mengira dan merekodkan kehilangan dan ketepatan pada set latihan dan ujian.

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. Gunakan PHP untuk memanggil skrip Python

Sekarang kami telah menyelesaikan penciptaan dan latihan model pembelajaran mendalam yang mudah, seterusnya kami akan memperkenalkan cara menggunakan PHP untuk memanggil Skrip Python ini akan menggunakan model terlatih untuk aplikasi praktikal.

Kita boleh menggunakan fungsi exec PHP untuk memanggil skrip Python, contohnya:

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

Arahan ini akan melaksanakan skrip train.py dan menyimpan hasil output dalam tatasusunan $output_array. Jika proses latihan memakan masa, kami boleh menggunakan fungsi flush PHP untuk mencapai output masa nyata, seperti:

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

Dengan cara ini, kami boleh menyepadukan model pembelajaran mendalam ke dalam aplikasi PHP kami dan Gunakannya untuk menyediakan pelbagai fungsi pintar.

4. Ringkasan

Artikel ini memperkenalkan cara menggunakan PHP dan PyTorch untuk pembelajaran mendalam, termasuk mencipta dan melatih model klasifikasi digit tulisan tangan yang mudah, dan cara membenamkan model ini ke tengah aplikasi PHP . Dengan cara ini, kami boleh menggunakan model pembelajaran mendalam pada pelbagai aplikasi web dan tapak web untuk menyediakan fungsi dan perkhidmatan yang lebih pintar.

Atas ialah kandungan terperinci Pembelajaran Mendalam dengan PHP dan PyTorch. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!