Hvordan kommer man i gang med dyb læring ved hjælp af gratis ressourcer? En praktisk guide

Dyb læring er en kernekomponent i kunstig intelligens og ændrer vores liv og arbejde med en hidtil uset hastighed. Fra selvkørende biler til medicinsk diagnose og naturlig sprogbehandling er dyb læring overalt. For begyndere kan den teoretiske viden og praktiske drift af dyb læring dog virke lidt skræmmende. Heldigvis er der et væld af gratis ressourcer på internettet, der kan hjælpe os med at komme let i gang. Denne artikel vil, baseret på diskussioner på X/Twitter, sammensætte en praktisk guide til at komme i gang med dyb læring, der hjælper dig med at mestre de centrale begreber og færdigheder inden for dyb læring fra bunden.

1. Forstå det grundlæggende i dyb læring

Inden du dykker ned i praksis, er det afgørende at forstå de grundlæggende begreber i dyb læring. Som @@techhybrindia påpeger, er AI ikke kun data og algoritmer, men kræver også stærk computerkraft. Dyb læringsmodeller kræver et stort antal GPU- eller TPU-ressourcer samt enorme mængder hukommelse og højhastigheds computerkraft for at kunne trænes. Derfor er det vigtigt at forstå disse hardware-fundamenter for at forstå omfanget og kompleksiteten af dyb læring.

Nøglebegreber:

• Neurale netværk (Neural Networks): Grundlaget for dyb læring, der efterligner forbindelsen mellem neuroner i den menneskelige hjerne.
• Dybde (Depth): Refererer til antallet af lag i et neuralt netværk. Jo flere lag, jo mere komplekse funktioner kan modellen lære.
• Backpropagation (Backpropagation): Den centrale algoritme til træning af neurale netværk, der bruges til at opdatere vægtene i netværket.
• Aktiveringsfunktioner (Activation Functions): Introducerer ikke-linearitet, hvilket gør det muligt for neurale netværk at lære komplekse mønstre. For eksempel ReLU, Sigmoid, Tanh osv.
• Tabsfuktioner (Loss Functions): Måler forskellen mellem modellens forudsigelser og de faktiske resultater, der bruges til at optimere modelparametre. For eksempel Mean Squared Error (MSE), Cross-Entropy Loss osv.
• Optimeringsværktøjer (Optimizers): Bruges til at opdatere modelparametre og reducere værdien af tabsfunktionen. For eksempel Gradient Descent, Adam, SGD osv.

Gratis læringsressourcer:

• Bøger:

  • @@khushabu_27, @@swapnakpanda, @@Shruti_0810 delte MIT's gratis AI & ML-bøger, hvoraf "Understanding Deep Learning" er en rigtig god introduktion.
    • Understanding Deep Learning: Denne bog introducerer dyb lærings forskellige aspekter på en letforståelig måde, fra grundlæggende begreber til avancerede teknikker.
    • Foundations of Machine Learning: Denne bog dækker de grundlæggende teorier bag maskinlæring, hvilket er meget nyttigt til at forstå principperne bag dyb læring.
  • @@KirkDBorne anbefalede "Why Machines Learn — The Elegant Math Behind Modern AI" og "Deep Learning Foundations and Concepts", som kan hjælpe dig med at forstå dyb læring fra et matematisk perspektiv.

• Online kurser:

  • @@shamimai1 anbefalede de gratis kurser fra Google, såsom "Understanding machine learning" og "Introduction to Large Language Models", som kan hjælpe dig med hurtigt at forstå de grundlæggende begreber inden for dyb læring og LLM.
  • @@mehmetsongur_ delte MIT's Deep Learning-kursusvideoer, som kan ses på Youtube. MIT Deep Learning Course## 2. Opsætning af et Deep Learning-miljø

For at praktisere deep learning skal du først opsætte et passende udviklingsmiljø. Almindeligt anvendte deep learning-frameworks inkluderer TensorFlow og PyTorch.

Trin:

1. Installer Python: Deep learning udvikles primært ved hjælp af Python-sproget. Det anbefales at installere Python 3.6 eller nyere.
2. Installer TensorFlow eller PyTorch:
   • TensorFlow:

     pip install tensorflow
     # Hvis din maskine har en NVIDIA GPU, og CUDA og cuDNN allerede er installeret, kan du installere GPU-versionen af TensorFlow
     # pip install tensorflow-gpu
     

   • PyTorch:

     # Vælg den passende installationskommando baseret på dit operativsystem og CUDA-version, for eksempel:
     pip install torch torchvision torchaudio
     # Det anbefales at besøge PyTorch's officielle hjemmeside (https://pytorch.org/) for at få de nyeste installationskommandoer
     

3. Installer andre nødvendige biblioteker: F.eks. NumPy, Pandas, Matplotlib osv.

   pip install numpy pandas matplotlib scikit-learn
   

4. Brug Jupyter Notebook eller Google Colab: Jupyter Notebook giver et interaktivt programmeringsmiljø, der er meget velegnet til deep learning-eksperimenter og -læring. Google Colab tilbyder gratis GPU-ressourcer, som giver dig mulighed for at træne deep learning i skyen.

3. Praktisk erfaring: Byg din første deep learning-model

Teoretisk læring er vigtig, men praktisk erfaring er endnu vigtigere. Her er et simpelt eksempel, der bruger Keras (TensorFlows high-level API) til at bygge en deep learning-model til billedklassificering:

Trin:

1. Importer de nødvendige biblioteker:

   import tensorflow as tf
   from tensorflow import keras
   from tensorflow.keras import layers
   import matplotlib.pyplot as plt
   

2. Indlæs datasættet: Brug Keras' indbyggede MNIST-datasæt (håndskrevne talbilleder).

   (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
   

3. Forbehandling af data: Normaliser billeddataene til mellem 0-1.

   x_train = x_train.astype("float32") / 255.0
   x_test = x_test.astype("float32") / 255.0
   

4. Opbyg modellen: Brug Keras Sequential API til at opbygge en simpel CNN-model.

   model = keras.Sequential(
       [
           keras.Input(shape=(28, 28, 1)),
           layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
           layers.MaxPooling2D(pool_size=(2, 2)),
           layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
           layers.MaxPooling2D(pool_size=(2, 2)),
           layers.Flatten(),
           layers.Dropout(0.5),
           layers.Dense(10, activation="softmax"),
       ]
   )
   model.summary() # Udskriv modelstrukturen
   

5. Kompiler modellen: Konfigurer optimeringsfunktion, tabsfuntion og evalueringsmetrikker.

   model.compile(loss="sparse_categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
   

6. Træn modellen:

   batch_size = 128
   epochs = 10
   model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)
   

7. Evaluer modellen:

   score = model.evaluate(x_test, y_test, verbose=0)
   print("Test loss:", score[0])
   print("Test accuracy:", score[1])
   

8. Vis resultater

   # Visualiser nogle forudsigelsesresultater fra testdatasættet
   predictions = model.predict(x_test[:10])
   predicted_labels = [tf.argmax(prediction).numpy() for prediction in predictions]
   ```## 3. 构建你的第一个神经网络
   

现在，让我们用 Python 和 TensorFlow/Keras 构建一个简单的神经网络来解决一个实际问题。我们将使用 MNIST 手写数字数据集，这是一个经典的深度学习入门数据集。

3.1 准备数据

首先，我们需要加载 MNIST 数据集并进行预处理。

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
import numpy as np

# 加载 MNIST 数据集
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# 打印数据集的形状
print('x_train shape:', x_train.shape) # 训练集图像的形状
print('y_train shape:', y_train.shape) # 训练集标签的形状
print('x_test shape:', x_test.shape)   # 测试集图像的形状
print('y_test shape:', y_test.shape)   # 测试集标签的形状

3.2 数据预处理

接下来，我们需要对数据进行预处理，包括：

• 将像素值缩放到 0 到 1 之间。
• 将标签转换为 one-hot 编码。

# 像素值缩放到 0 到 1 之间
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# 将标签转换为 one-hot 编码
y_train = keras.utils.to_categorical(y_train, num_classes=10)
y_test = keras.utils.to_categorical(y_test, num_classes=10)

3.3 构建模型

现在，我们可以构建我们的神经网络模型。我们将使用一个简单的多层感知器 (MLP) 模型。

# 构建模型
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)), # 将 28x28 的图像展平成 784 维的向量
    keras.layers.Dense(128, activation='relu'), # 具有 128 个神经元的全连接层，使用 ReLU 激活函数
    keras.layers.Dense(10, activation='softmax') # 具有 10 个神经元的全连接层，使用 Softmax 激活函数，输出每个类别的概率
])

# 编译模型
model.compile(optimizer='adam', # 使用 Adam 优化器
              loss='categorical_crossentropy', # 使用交叉熵损失函数
              metrics=['accuracy']) # 评估指标为准确率

# 打印模型结构
model.summary()

3.4 训练模型

接下来，我们可以训练我们的模型。

# 训练模型
model.fit(x_train, y_train, epochs=5, batch_size=32) # 训练 5 个 epoch，每个 batch 的大小为 32

3.5 评估模型

训练完成后，我们可以评估我们的模型在测试集上的性能。

# 评估模型
loss, accuracy = model.evaluate(x_test, y_test)
print('Test accuracy:', accuracy) # 打印测试集上的准确率

3.6 进行预测

最后，我们可以使用我们的模型进行预测。

# 进行预测
predictions = model.predict(x_test)

# 将预测结果转换为标签
predicted_labels = np.argmax(predictions, axis=1)

# 可视化预测结果
plt.figure(figsize=(15, 5))
for i in range(10):
    plt.subplot(1, 10, i+1)
    plt.imshow(x_test[i], cmap='gray')
    plt.title(fDyb læring er et felt fyldt med muligheder og udfordringer. Ved at udnytte gratis ressourcer, opbygge et passende udviklingsmiljø og insistere på praksis, kan du også mestre de centrale koncepter og færdigheder inden for dyb læring og anvende dem på praktiske problemer. Håber denne artikel kan hjælpe dig med at komme godt i gang med dyb læring og gå længere og længere ad kunstig intelligens' vej!