इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

मॉडल प्रशिक्षण पूर्वाभ्यास

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें

यह गाइड एक मशीन लर्निंग मॉडल का निर्माण करके TensorFlow के लिए स्विफ्ट का परिचय देता है जो प्रजातियों द्वारा आईरिस फूलों को वर्गीकृत करता है। यह TensorFlow के लिए स्विफ्ट का उपयोग करता है:

  1. मॉडल बनाना,
  2. उदाहरण डेटा पर इस मॉडल को प्रशिक्षित करें, और
  3. अज्ञात डेटा के बारे में पूर्वानुमान बनाने के लिए मॉडल का उपयोग करें।

TensorFlow प्रोग्रामिंग

यह गाइड TensorFlow अवधारणाओं के लिए इन उच्च-स्तरीय स्विफ्ट का उपयोग करता है:

  • एपोच एपीआई के साथ डेटा आयात करें।
  • स्विफ्ट अमूर्त का उपयोग कर मॉडल बनाएं।
  • जब स्विफ्ट की लाइब्रेरी उपलब्ध नहीं हैं, तो स्विफ्ट के पायथन इंटरऑपरेबिलिटी का उपयोग करके पायथन लाइब्रेरी का उपयोग करें।

यह ट्यूटोरियल कई TensorFlow कार्यक्रमों की तरह संरचित है:

  1. डेटा सेट आयात और पार्स करें।
  2. मॉडल के प्रकार का चयन करें।
  3. मॉडल को प्रशिक्षित करें।
  4. मॉडल की प्रभावशीलता का मूल्यांकन करें।
  5. पूर्वानुमान बनाने के लिए प्रशिक्षित मॉडल का उपयोग करें।

सेटअप प्रोग्राम

आयात कॉन्फ़िगर करें

TensorFlow और कुछ उपयोगी पायथन मॉड्यूल आयात करें।

import TensorFlow
import PythonKit
// This cell is here to display the plots in a Jupyter Notebook.
// Do not copy it into another environment.
%include "EnableIPythonDisplay.swift"
IPythonDisplay.shell.enable_matplotlib("inline")
('inline', 'module://ipykernel.pylab.backend_inline')

let plt = Python.import("matplotlib.pyplot")
dd9006020

आईरिस वर्गीकरण समस्या

कल्पना कीजिए कि आप एक वनस्पति विज्ञानी हैं जो प्रत्येक आइरिस फूल को वर्गीकृत करने के लिए एक स्वचालित तरीका ढूंढ रहे हैं। मशीन लर्निंग सांख्यिकीय रूप से फूलों को वर्गीकृत करने के लिए कई एल्गोरिदम प्रदान करता है। उदाहरण के लिए, एक परिष्कृत मशीन लर्निंग प्रोग्राम तस्वीरों के आधार पर फूलों को वर्गीकृत कर सकता है। हमारी महत्वाकांक्षाएं अधिक विनम्र हैं - हम अपने सेपल्स और पंखुड़ियों की लंबाई और चौड़ाई माप के आधार पर आईरिस फूलों को वर्गीकृत करने जा रहे हैं

आइरिस जीनस में लगभग 300 प्रजातियां शामिल हैं, लेकिन हमारा कार्यक्रम केवल निम्नलिखित तीन को वर्गीकृत करेगा:

  • आइरिस सेटोसा
  • आइरिस वर्जिनिका
  • आइरिस छंद
तीन आइरिस प्रजातियों की तुलना में पेटल ज्यामिति: आइरिस सेटोसा, आइरिस वर्जिनिका और आइरिस वर्सिकोलर
चित्र 1. आइरिस सेटोसा ( रेडोमिल , सीसी बाय-एसए 3.0 द्वारा), आइरिस वर्सिकोलर , ( डेलंग्लोइस , सीसी बाय-एसए 3.0), और आइरिस वर्जिनिका ( फ्रैंक मेफील्ड , सीसी बाय-एसए 2.0 द्वारा)।

सौभाग्य से, किसी ने पहले ही सेपाल और पंखुड़ी माप के साथ 120 आईरिस फूलों का एक डेटा सेट बनाया है। यह एक क्लासिक डेटासेट है जो शुरुआती मशीन लर्निंग वर्गीकरण समस्याओं के लिए लोकप्रिय है।

प्रशिक्षण डेटासेट आयात और पार्स करें

डेटासेट फ़ाइल डाउनलोड करें और इसे एक संरचना में परिवर्तित करें जिसका उपयोग इस स्विफ्ट प्रोग्राम द्वारा किया जा सकता है।

डेटासेट डाउनलोड करें

Http://download.tensorflow.org/data/iris_training.csv से प्रशिक्षण डेटासेट फ़ाइल डाउनलोड करें

let trainDataFilename = "iris_training.csv"
download(from: "http://download.tensorflow.org/data/iris_training.csv", to: trainDataFilename)

डेटा का निरीक्षण करें

यह डेटासेट, iris_training.csv , एक सादा पाठ फ़ाइल है जो तालिका डेटा को अल्पविराम से अलग किए गए मान (CSV) के रूप में संग्रहीत करता है। आइए पहले 5 प्रविष्टियों को देखें।

let f = Python.open(trainDataFilename)
for _ in 0..<5 {
    print(Python.next(f).strip())
}
f.close()
120,4,setosa,versicolor,virginica
6.4,2.8,5.6,2.2,2
5.0,2.3,3.3,1.0,1
4.9,2.5,4.5,1.7,2
4.9,3.1,1.5,0.1,0

None

डेटासेट के इस दृष्टिकोण से, निम्नलिखित पर ध्यान दें:

  1. पहली पंक्ति एक शीर्ष लेख है जिसमें डेटासेट के बारे में जानकारी है:
    • कुल 120 उदाहरण हैं। प्रत्येक उदाहरण में चार विशेषताएं हैं और तीन संभावित लेबल नामों में से एक है।
  2. बाद की पंक्तियाँ डेटा रिकॉर्ड हैं, प्रति पंक्ति एक उदाहरण , जहां:
    • पहले चार क्षेत्र विशेषताएं हैं : ये एक उदाहरण की विशेषताएं हैं। यहां, फूल के मापों को दर्शाने वाले क्षेत्र फ्लोट संख्या रखते हैं।
    • अंतिम कॉलम लेबल है : यह वह मूल्य है जिसकी हम भविष्यवाणी करना चाहते हैं। इस डेटासेट के लिए, यह 0, 1, या 2 का पूर्णांक मान है जो एक फूल के नाम से मेल खाता है।

कोड में लिखते हैं कि:

let featureNames = ["sepal_length", "sepal_width", "petal_length", "petal_width"]
let labelName = "species"
let columnNames = featureNames + [labelName]

print("Features: \(featureNames)")
print("Label: \(labelName)")
Features: ["sepal_length", "sepal_width", "petal_length", "petal_width"]
Label: species

प्रत्येक लेबल स्ट्रिंग नाम (उदाहरण के लिए, "सेटोसा") के साथ जुड़ा हुआ है, लेकिन मशीन लर्निंग आमतौर पर संख्यात्मक मानों पर निर्भर करता है। लेबल संख्याओं को नामांकित प्रतिनिधित्व के लिए मैप किया जाता है, जैसे:

  • 0 : आइरिस सेटोसा
  • 1 : आइरिस वर्सिकलर
  • 2 : आइरिस वर्जिनिका

सुविधाओं और लेबल के बारे में अधिक जानकारी के लिए, मशीन लर्निंग क्रैश कोर्स के एमएल टर्मिनोलॉजी अनुभाग देखें।

let classNames = ["Iris setosa", "Iris versicolor", "Iris virginica"]

एपिच एपीआई का उपयोग करके एक डेटासेट बनाएं

TensorFlow के युग एपीआई के लिए स्विफ्ट डेटा पढ़ने और इसे प्रशिक्षण के लिए उपयोग किए जाने वाले फ़ॉर्म में बदलने के लिए एक उच्च-स्तरीय एपीआई है।

let batchSize = 32

/// A batch of examples from the iris dataset.
struct IrisBatch {
    /// [batchSize, featureCount] tensor of features.
    let features: Tensor<Float>

    /// [batchSize] tensor of labels.
    let labels: Tensor<Int32>
}

/// Conform `IrisBatch` to `Collatable` so that we can load it into a `TrainingEpoch`.
extension IrisBatch: Collatable {
    public init<BatchSamples: Collection>(collating samples: BatchSamples)
        where BatchSamples.Element == Self {
        /// `IrisBatch`es are collated by stacking their feature and label tensors
        /// along the batch axis to produce a single feature and label tensor
        features = Tensor<Float>(stacking: samples.map{$0.features})
        labels = Tensor<Int32>(stacking: samples.map{$0.labels})
    }
}

चूंकि हमारे द्वारा डाउनलोड किए गए डेटासेट CSV प्रारूप में हैं, आइए IBBatch ऑब्जेक्ट्स की सूची के रूप में डेटा में लोड करने के लिए एक फ़ंक्शन लिखते हैं।

/// Initialize an `IrisBatch` dataset from a CSV file.
func loadIrisDatasetFromCSV(
        contentsOf: String, hasHeader: Bool, featureColumns: [Int], labelColumns: [Int]) -> [IrisBatch] {
        let np = Python.import("numpy")

        let featuresNp = np.loadtxt(
            contentsOf,
            delimiter: ",",
            skiprows: hasHeader ? 1 : 0,
            usecols: featureColumns,
            dtype: Float.numpyScalarTypes.first!)
        guard let featuresTensor = Tensor<Float>(numpy: featuresNp) else {
            // This should never happen, because we construct featuresNp in such a
            // way that it should be convertible to tensor.
            fatalError("np.loadtxt result can't be converted to Tensor")
        }

        let labelsNp = np.loadtxt(
            contentsOf,
            delimiter: ",",
            skiprows: hasHeader ? 1 : 0,
            usecols: labelColumns,
            dtype: Int32.numpyScalarTypes.first!)
        guard let labelsTensor = Tensor<Int32>(numpy: labelsNp) else {
            // This should never happen, because we construct labelsNp in such a
            // way that it should be convertible to tensor.
            fatalError("np.loadtxt result can't be converted to Tensor")
        }

        return zip(featuresTensor.unstacked(), labelsTensor.unstacked()).map{IrisBatch(features: $0.0, labels: $0.1)}

    }

अब हम प्रशिक्षण डेटासेट को लोड करने और एक TrainingEpochs ऑब्जेक्ट बनाने के लिए सीएसवी लोडिंग फ़ंक्शन का उपयोग कर सकते हैं

let trainingDataset: [IrisBatch] = loadIrisDatasetFromCSV(contentsOf: trainDataFilename, 
                                                  hasHeader: true, 
                                                  featureColumns: [0, 1, 2, 3], 
                                                  labelColumns: [4])

let trainingEpochs: TrainingEpochs = TrainingEpochs(samples: trainingDataset, batchSize: batchSize)

TrainingEpochs वस्तु युगों का एक अनंत क्रम है। प्रत्येक युग में IrisBatch एस शामिल हैं। आइए पहले युग के पहले तत्व को देखें।

let firstTrainEpoch = trainingEpochs.next()!
let firstTrainBatch = firstTrainEpoch.first!.collated
let firstTrainFeatures = firstTrainBatch.features
let firstTrainLabels = firstTrainBatch.labels

print("First batch of features: \(firstTrainFeatures)")
print("firstTrainFeatures.shape: \(firstTrainFeatures.shape)")
print("First batch of labels: \(firstTrainLabels)")
print("firstTrainLabels.shape: \(firstTrainLabels.shape)")
First batch of features: [[5.0, 2.3, 3.3, 1.0],
 [5.6, 2.9, 3.6, 1.3],
 [5.7, 2.8, 4.1, 1.3],
 [4.4, 2.9, 1.4, 0.2],
 [5.0, 3.2, 1.2, 0.2],
 [4.9, 3.1, 1.5, 0.1],
 [4.9, 3.1, 1.5, 0.1],
 [5.8, 2.6, 4.0, 1.2],
 [5.8, 2.7, 5.1, 1.9],
 [5.0, 3.5, 1.3, 0.3],
 [6.3, 2.5, 5.0, 1.9],
 [4.6, 3.1, 1.5, 0.2],
 [5.9, 3.2, 4.8, 1.8],
 [6.9, 3.2, 5.7, 2.3],
 [5.7, 4.4, 1.5, 0.4],
 [5.8, 2.8, 5.1, 2.4],
 [5.4, 3.0, 4.5, 1.5],
 [6.3, 3.4, 5.6, 2.4],
 [5.9, 3.0, 5.1, 1.8],
 [4.6, 3.4, 1.4, 0.3],
 [5.0, 3.4, 1.6, 0.4],
 [6.3, 2.3, 4.4, 1.3],
 [4.4, 3.0, 1.3, 0.2],
 [5.5, 2.6, 4.4, 1.2],
 [5.4, 3.7, 1.5, 0.2],
 [5.0, 3.4, 1.5, 0.2],
 [6.8, 3.0, 5.5, 2.1],
 [6.2, 2.8, 4.8, 1.8],
 [5.4, 3.9, 1.7, 0.4],
 [7.7, 2.6, 6.9, 2.3],
 [4.9, 3.1, 1.5, 0.1],
 [5.8, 2.7, 4.1, 1.0]]
firstTrainFeatures.shape: [32, 4]
First batch of labels: [1, 1, 1, 0, 0, 0, 0, 1, 2, 0, 2, 0, 1, 2, 0, 2, 1, 2, 2, 0, 0, 1, 0, 1, 0, 0, 2, 2, 0, 2, 0, 1]
firstTrainLabels.shape: [32]

सूचना है कि पहले के लिए सुविधाओं batchSize उदाहरण एक साथ में बांटा गया है (या batched) firstTrainFeatures , और पहले के लिए लेबल है कि batchSize उदाहरण में batched रहे firstTrainLabels

आप पायथन के matplotlib का उपयोग करते हुए, बैच से कुछ सुविधाओं की साजिश रचकर कुछ समूहों को देखना शुरू कर सकते हैं:

let firstTrainFeaturesTransposed = firstTrainFeatures.transposed()
let petalLengths = firstTrainFeaturesTransposed[2].scalars
let sepalLengths = firstTrainFeaturesTransposed[0].scalars

plt.scatter(petalLengths, sepalLengths, c: firstTrainLabels.array.scalars)
plt.xlabel("Petal length")
plt.ylabel("Sepal length")
plt.show()

png

None

मॉडल के प्रकार का चयन करें

क्यों मॉडल?

एक मॉडल सुविधाओं और लेबल के बीच का संबंध है। आईरिस वर्गीकरण समस्या के लिए, मॉडल सेपल और पंखुड़ी माप और पूर्वानुमानित आईरिस प्रजातियों के बीच संबंध को परिभाषित करता है। कुछ सरल मॉडलों को बीजगणित की कुछ पंक्तियों के साथ वर्णित किया जा सकता है, लेकिन जटिल मशीन लर्निंग मॉडल में बड़ी संख्या में पैरामीटर हैं जिन्हें संक्षेप में प्रस्तुत करना मुश्किल है।

क्या आप मशीन लर्निंग का उपयोग किए बिना चार विशेषताओं और परितारिका प्रजातियों के बीच संबंध निर्धारित कर सकते हैं? यही है, क्या आप मॉडल बनाने के लिए पारंपरिक प्रोग्रामिंग तकनीकों (उदाहरण के लिए, बहुत सारे सशर्त बयान) का उपयोग कर सकते हैं? शायद - अगर आपने किसी विशेष प्रजाति के पंखुड़ी और सीपल माप के बीच संबंधों को निर्धारित करने के लिए लंबे समय तक डेटासेट का विश्लेषण किया। और यह और अधिक जटिल डेटासेट पर-शायद असंभव हो जाता है। एक अच्छा मशीन लर्निंग दृष्टिकोण आपके लिए मॉडल निर्धारित करता है । यदि आप सही मशीन लर्निंग मॉडल प्रकार में पर्याप्त प्रतिनिधि उदाहरण फ़ीड करते हैं, तो प्रोग्राम आपके लिए रिश्तों का पता लगाएगा।

मॉडल का चयन करें

हमें प्रशिक्षित करने के लिए मॉडल के प्रकार का चयन करने की आवश्यकता है। कई तरह के मॉडल हैं और एक अच्छा अनुभव लेने के लिए। यह ट्यूटोरियल आईरिस वर्गीकरण समस्या को हल करने के लिए एक तंत्रिका नेटवर्क का उपयोग करता है। तंत्रिका नेटवर्क सुविधाओं और लेबल के बीच जटिल संबंध पा सकते हैं। यह एक उच्च संरचित ग्राफ़ है, जिसे एक या अधिक छिपी हुई परतों में व्यवस्थित किया जाता है। प्रत्येक छिपी हुई परत में एक या अधिक न्यूरॉन्स होते हैं । तंत्रिका नेटवर्क की कई श्रेणियां हैं और यह कार्यक्रम एक घने, या पूरी तरह से जुड़े तंत्रिका नेटवर्क का उपयोग करता है: एक परत में न्यूरॉन्स पिछली परत में प्रत्येक न्यूरॉन से इनपुट कनेक्शन प्राप्त करते हैं। उदाहरण के लिए, चित्रा 2 एक घने तंत्रिका नेटवर्क को दिखाता है जिसमें एक इनपुट परत, दो छिपी परतें और एक आउटपुट परत शामिल है:

नेटवर्क आर्किटेक्चर का एक आरेख: इनपुट, 2 छिपी हुई परतें, और आउटपुट
चित्रा 2. सुविधाओं, छिपी हुई परतों और भविष्यवाणियों के साथ एक तंत्रिका नेटवर्क।

जब चित्र 2 से मॉडल को प्रशिक्षित किया जाता है और एक अप्रकाशित उदाहरण खिलाया जाता है, तो यह तीन भविष्यवाणियों को जन्म देता है: संभावना है कि यह फूल दी गई आईरिस प्रजाति है। इस भविष्यवाणी को अनुमान कहा जाता है। इस उदाहरण के लिए, आउटपुट भविष्यवाणियों का योग 1.0 है। चित्रा 2 में, यह भविष्यवाणी निम्नानुसार है : आइरिस सेटोसा के लिए 0.02 , आइरिस वर्सिकलर के लिए 0.95 , और आइरिस वर्जिनिका के लिए 0.03 । इसका मतलब यह है कि यह मॉडल 95% संभावना के साथ भविष्यवाणी करता है- कि एक बिना सोचे-समझे उदाहरण फूल एक आइरिस वर्सिकलर है

TensorFlow Deep Learning Library के लिए स्विफ्ट का उपयोग करके एक मॉडल बनाएं

TensorFlow Deep Learning Library के लिए Swift उन्हें एक साथ वायरिंग करने के लिए आदिम परतों और सम्मेलनों को परिभाषित करती है , जिससे मॉडल बनाना और प्रयोग करना आसान हो जाता है।

एक मॉडल एक है struct कि के अनुरूप Layer , जिसका अर्थ है कि यह एक को परिभाषित करता है callAsFunction(_:) विधि है कि नक्शे इनपुट Tensor के उत्पादन रों Tensor रों। callAsFunction(_:) विधि अक्सर callAsFunction(_:) माध्यम से इनपुट को अनुक्रमित करती है। आइए एक IrisModel को परिभाषित करें जो तीन Dense सबलेयर के माध्यम से इनपुट को अनुक्रमित करता है।

import TensorFlow

let hiddenSize: Int = 10
struct IrisModel: Layer {
    var layer1 = Dense<Float>(inputSize: 4, outputSize: hiddenSize, activation: relu)
    var layer2 = Dense<Float>(inputSize: hiddenSize, outputSize: hiddenSize, activation: relu)
    var layer3 = Dense<Float>(inputSize: hiddenSize, outputSize: 3)
    
    @differentiable
    func callAsFunction(_ input: Tensor<Float>) -> Tensor<Float> {
        return input.sequenced(through: layer1, layer2, layer3)
    }
}

var model = IrisModel()

सक्रियण फ़ंक्शन परत में प्रत्येक नोड के आउटपुट आकार को निर्धारित करता है। ये गैर-रेखीय महत्वपूर्ण हैं - उनके बिना मॉडल एक परत के बराबर होगा। कई उपलब्ध सक्रियण हैं, लेकिन ReLU छिपी हुई परतों के लिए आम है।

छिपी हुई परतों और न्यूरॉन्स की आदर्श संख्या समस्या और डेटासेट पर निर्भर करती है। मशीन लर्निंग के कई पहलुओं की तरह, तंत्रिका नेटवर्क का सबसे अच्छा आकार चुनने के लिए ज्ञान और प्रयोग के मिश्रण की आवश्यकता होती है। अंगूठे के एक नियम के रूप में, छिपी हुई परतों और न्यूरॉन्स की संख्या में वृद्धि आमतौर पर एक अधिक शक्तिशाली मॉडल बनाती है, जिसे प्रभावी ढंग से प्रशिक्षित करने के लिए अधिक डेटा की आवश्यकता होती है।

मॉडल का उपयोग करना

आइए इस मॉडल के बैच के लिए इस मॉडल पर एक त्वरित नज़र डालें:

// Apply the model to a batch of features.
let firstTrainPredictions = model(firstTrainFeatures)
firstTrainPredictions[0..<5]
[[ -0.8188498,   1.5179185,  -0.3823631],
 [ -0.8939362,   1.8654141,   -0.431251],
 [  -0.877989,   1.6670536, -0.37928653],
 [-0.62468827,   1.7252572,  -0.3766331],
 [-0.68565977,   2.0301576, -0.44697276]]

यहां, प्रत्येक उदाहरण प्रत्येक वर्ग के लिए एक लॉगिट लौटाता है।

प्रत्येक वर्ग के लिए इन लॉग को संभाव्यता में बदलने के लिए, सॉफ्टमैक्स फ़ंक्शन का उपयोग करें:

softmax(firstTrainPredictions[0..<5])
[[ 0.07754943,   0.8024614, 0.119989246],
 [ 0.05441314,   0.8591607,   0.0864262],
 [ 0.06497577,   0.8280362,  0.10698802],
 [ 0.07832983,   0.8212881, 0.100382075],
 [0.057515744,   0.8694633,   0.0730209]]

कक्षाओं में argmax लेने से हमें अनुमानित कक्षा सूचकांक मिलता है। लेकिन, मॉडल को अभी तक प्रशिक्षित नहीं किया गया है, इसलिए ये अच्छी भविष्यवाणियां नहीं हैं।

print("Prediction: \(firstTrainPredictions.argmax(squeezingAxis: 1))")
print("    Labels: \(firstTrainLabels)")
Prediction: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
    Labels: [1, 1, 1, 0, 0, 0, 0, 1, 2, 0, 2, 0, 1, 2, 0, 2, 1, 2, 2, 0, 0, 1, 0, 1, 0, 0, 2, 2, 0, 2, 0, 1]

मॉडल को प्रशिक्षित करें

प्रशिक्षण मशीन सीखने का चरण है जब मॉडल को धीरे-धीरे अनुकूलित किया जाता है, या मॉडल डेटासेट सीखता है। लक्ष्य डेटा डेटासेट की संरचना के बारे में पर्याप्त जानकारी सीखना है जो अनदेखी डेटा के बारे में भविष्यवाणियां करता है। यदि आप प्रशिक्षण डेटासेट के बारे में बहुत अधिक सीखते हैं , तो भविष्यवाणियाँ केवल उस डेटा के लिए काम करती हैं जिसे उसने देखा है और सामान्य नहीं होगा। इस समस्या को ओवरफिटिंग कहा जाता है - जैसे किसी समस्या को हल करने के तरीके को समझने के बजाय उत्तरों को याद रखना।

आईरिस वर्गीकरण समस्या पर्यवेक्षित मशीन लर्निंग का एक उदाहरण है: मॉडल को उन उदाहरणों से प्रशिक्षित किया जाता है जिनमें लेबल होते हैं। अनुपयोगी मशीन सीखने में , उदाहरणों में लेबल नहीं होते हैं। इसके बजाय, मॉडल आमतौर पर सुविधाओं के बीच पैटर्न पाता है।

एक हानि फ़ंक्शन चुनें

प्रशिक्षण और मूल्यांकन चरणों दोनों को मॉडल के नुकसान की गणना करने की आवश्यकता होती है। यह मापता है कि किसी मॉडल की भविष्यवाणियां वांछित लेबल से कैसे होती हैं, दूसरे शब्दों में, मॉडल कितना खराब प्रदर्शन कर रहा है। हम इस मान को कम से कम या अनुकूलित करना चाहते हैं।

हमारा मॉडल softmaxCrossEntropy(logits:labels:) फ़ंक्शन का उपयोग करके अपने नुकसान की गणना करेगा जो मॉडल की कक्षा की संभाव्यता की भविष्यवाणी और वांछित लेबल लेता है, और उदाहरणों में औसत हानि लौटाता है।

आइए वर्तमान अप्रशिक्षित मॉडल के नुकसान की गणना करें:

let untrainedLogits = model(firstTrainFeatures)
let untrainedLoss = softmaxCrossEntropy(logits: untrainedLogits, labels: firstTrainLabels)
print("Loss test: \(untrainedLoss)")
Loss test: 1.8843782

let optimizer = SGD(for: model, learningRate: 0.01)

चलो एक एकल ढाल वंश कदम लेने के लिए optimizer का उपयोग करें। सबसे पहले, हम मॉडल के संबंध में नुकसान की प्रवणता की गणना करते हैं:

let (loss, grads) = valueWithGradient(at: model) { model -> Tensor<Float> in
    let logits = model(firstTrainFeatures)
    return softmaxCrossEntropy(logits: logits, labels: firstTrainLabels)
}
print("Current loss: \(loss)")
Current loss: 1.8843782

इसके बाद, हम उस ग्रेडिएंट को पास करते हैं, जिसे हमने अभी-अभी ऑप्टिमाइज़र के लिए परिकलित किया है, जो तदनुसार मॉडल के विभेदी चर को अद्यतन करता है:

optimizer.update(&model, along: grads)

यदि हम नुकसान की फिर से गणना करते हैं, तो यह छोटा होना चाहिए, क्योंकि ढाल वंश कदम (आमतौर पर) नुकसान को कम करते हैं:

let logitsAfterOneStep = model(firstTrainFeatures)
let lossAfterOneStep = softmaxCrossEntropy(logits: logitsAfterOneStep, labels: firstTrainLabels)
print("Next loss: \(lossAfterOneStep)")
Next loss: 1.327492

प्रशिक्षण पाश

जगह में सभी टुकड़ों के साथ, मॉडल प्रशिक्षण के लिए तैयार है! एक प्रशिक्षण लूप बेहतर पूर्वानुमान बनाने में मदद करने के लिए मॉडल में डेटासेट उदाहरण खिलाता है। निम्न कोड ब्लॉक इन प्रशिक्षण चरणों को सेट करता है:

  1. प्रत्येक युग खत्म हो गया पुनरावृति। एपिक के माध्यम से एक युग एक मार्ग है।
  2. एक युग के भीतर, प्रशिक्षण युग में प्रत्येक बैच पर पुनरावृति
  3. बैच को मिलाएं और इसकी विशेषताओं ( x ) और लेबल ( y ) को पकड़ो।
  4. कोलाज किए गए बैच की विशेषताओं का उपयोग करते हुए, एक भविष्यवाणी करें और इसे लेबल के साथ तुलना करें। भविष्यवाणी की अशुद्धि को मापें और मॉडल के नुकसान और ग्रेडिएंट की गणना करने के लिए इसका उपयोग करें।
  5. मॉडल के चर को अद्यतन करने के लिए ढाल वंश का उपयोग करें।
  6. विज़ुअलाइज़ेशन के लिए कुछ आंकड़ों पर नज़र रखें।
  7. प्रत्येक युग के लिए दोहराएँ।

epochCount वेरिएबल कई बार डेटासेट संग्रह पर लूप करने की संख्या है। काउंटर-सहजता से, एक मॉडल को प्रशिक्षित करना बेहतर मॉडल की गारंटी नहीं देता है। epochCount एक है hyperparameter आप धुन कर सकते हैं। सही संख्या का चयन करने के लिए आमतौर पर अनुभव और प्रयोग दोनों की आवश्यकता होती है।

let epochCount = 500
var trainAccuracyResults: [Float] = []
var trainLossResults: [Float] = []
func accuracy(predictions: Tensor<Int32>, truths: Tensor<Int32>) -> Float {
    return Tensor<Float>(predictions .== truths).mean().scalarized()
}

for (epochIndex, epoch) in trainingEpochs.prefix(epochCount).enumerated() {
    var epochLoss: Float = 0
    var epochAccuracy: Float = 0
    var batchCount: Int = 0
    for batchSamples in epoch {
        let batch = batchSamples.collated
        let (loss, grad) = valueWithGradient(at: model) { (model: IrisModel) -> Tensor<Float> in
            let logits = model(batch.features)
            return softmaxCrossEntropy(logits: logits, labels: batch.labels)
        }
        optimizer.update(&model, along: grad)
        
        let logits = model(batch.features)
        epochAccuracy += accuracy(predictions: logits.argmax(squeezingAxis: 1), truths: batch.labels)
        epochLoss += loss.scalarized()
        batchCount += 1
    }
    epochAccuracy /= Float(batchCount)
    epochLoss /= Float(batchCount)
    trainAccuracyResults.append(epochAccuracy)
    trainLossResults.append(epochLoss)
    if epochIndex % 50 == 0 {
        print("Epoch \(epochIndex): Loss: \(epochLoss), Accuracy: \(epochAccuracy)")
    }
}
Epoch 0: Loss: 1.2097169, Accuracy: 0.4375
Epoch 50: Loss: 0.52431935, Accuracy: 0.875
Epoch 100: Loss: 0.3710712, Accuracy: 0.8958333
Epoch 150: Loss: 0.2160871, Accuracy: 0.9583333
Epoch 200: Loss: 0.14524944, Accuracy: 0.9791667
Epoch 250: Loss: 0.12487585, Accuracy: 0.9583333
Epoch 300: Loss: 0.122261345, Accuracy: 0.9791667
Epoch 350: Loss: 0.10571604, Accuracy: 0.9895833
Epoch 400: Loss: 0.09489065, Accuracy: 0.9791667
Epoch 450: Loss: 0.09057075, Accuracy: 0.9895833

समय के साथ नुकसान फ़ंक्शन की कल्पना करें

हालांकि यह मॉडल की प्रशिक्षण प्रगति को प्रिंट करने में मददगार है, यह अक्सर इस प्रगति को देखने के लिए अधिक उपयोगी है। हम Python के matplotlib मॉड्यूल का उपयोग करके बुनियादी चार्ट बना सकते हैं।

इन चार्ट की व्याख्या करने में कुछ अनुभव होता है, लेकिन आप वास्तव में नुकसान को कम होते देखना चाहते हैं और सटीकता बढ़ जाती है।

plt.figure(figsize: [12, 8])

let accuracyAxes = plt.subplot(2, 1, 1)
accuracyAxes.set_ylabel("Accuracy")
accuracyAxes.plot(trainAccuracyResults)

let lossAxes = plt.subplot(2, 1, 2)
lossAxes.set_ylabel("Loss")
lossAxes.set_xlabel("Epoch")
lossAxes.plot(trainLossResults)

plt.show()

png

None

ध्यान दें कि ग्राफ के y- अक्ष शून्य-आधारित नहीं हैं।

मॉडल की प्रभावशीलता का मूल्यांकन करें

अब जब मॉडल प्रशिक्षित हो गया है, तो हम इसके प्रदर्शन पर कुछ आंकड़े प्राप्त कर सकते हैं।

मूल्यांकन का अर्थ है यह निर्धारित करना कि मॉडल कितनी प्रभावी रूप से भविष्यवाणियां करता है। आईरिस वर्गीकरण में मॉडल की प्रभावशीलता को निर्धारित करने के लिए, मॉडल के लिए कुछ सीपल और पंखुड़ी माप पास करें और मॉडल से यह भविष्यवाणी करने के लिए कहें कि वे किस आइरिस प्रजाति का प्रतिनिधित्व करते हैं। फिर वास्तविक लेबल के खिलाफ मॉडल की भविष्यवाणी की तुलना करें। उदाहरण के लिए, आधे इनपुट उदाहरणों पर सही प्रजातियों को चुनने वाले मॉडल की सटीकता 0.5 । चित्रा 4 थोड़ा अधिक प्रभावी मॉडल दिखाता है, जिसमें से 5 में से 4 पूर्वानुमान 80% सटीकता पर सही हैं:

उदाहरण सुविधाएँ लेबल मॉडल की भविष्यवाणी
5.9 3.0 4.3 1.5 1 1
6.9 3.1 5.4 2.1 2 2
5.1 3.3 1.7 0.5 0 0
6.0 3.4 4.5 1.6 1 2
5.5 2.5 4.0 1.3 1 1
चित्रा 4. एक आईरिस क्लासिफायर जो 80% सटीक है।

परीक्षण डेटासेट सेट करें

मॉडल का मूल्यांकन करना मॉडल को प्रशिक्षित करने के समान है। सबसे बड़ा अंतर यह है कि उदाहरण प्रशिक्षण सेट के बजाय एक अलग परीक्षण सेट से आते हैं। किसी मॉडल की प्रभावशीलता का उचित मूल्यांकन करने के लिए, मॉडल का मूल्यांकन करने के लिए उपयोग किए जाने वाले उदाहरण मॉडल को प्रशिक्षित करने के लिए उपयोग किए जाने वाले उदाहरणों से अलग होना चाहिए।

परीक्षण डेटासेट के लिए सेटअप प्रशिक्षण डेटासेट के लिए सेटअप के समान है। Http://download.tensorflow.org/data/iris_test.csv से परीक्षण सेट डाउनलोड करें:

let testDataFilename = "iris_test.csv"
download(from: "http://download.tensorflow.org/data/iris_test.csv", to: testDataFilename)

अब इसे IrisBatch es की एक सरणी में लोड करें:

let testDataset = loadIrisDatasetFromCSV(
    contentsOf: testDataFilename, hasHeader: true,
    featureColumns: [0, 1, 2, 3], labelColumns: [4]).inBatches(of: batchSize)

परीक्षण डेटासेट पर मॉडल का मूल्यांकन करें

प्रशिक्षण चरण के विपरीत, मॉडल केवल परीक्षण डेटा के एकल युग का मूल्यांकन करता है। निम्नलिखित कोड सेल में, हम परीक्षण सेट में प्रत्येक उदाहरण पर पुनरावृति करते हैं और वास्तविक लेबल के खिलाफ मॉडल की भविष्यवाणी की तुलना करते हैं। इसका उपयोग पूरे परीक्षण सेट में मॉडल की सटीकता को मापने के लिए किया जाता है।

// NOTE: Only a single batch will run in the loop since the batchSize we're using is larger than the test set size
for batchSamples in testDataset {
    let batch = batchSamples.collated
    let logits = model(batch.features)
    let predictions = logits.argmax(squeezingAxis: 1)
    print("Test batch accuracy: \(accuracy(predictions: predictions, truths: batch.labels))")
}
Test batch accuracy: 0.96666664

हम पहले बैच पर देख सकते हैं, उदाहरण के लिए, मॉडल आमतौर पर सही है:

let firstTestBatch = testDataset.first!.collated
let firstTestBatchLogits = model(firstTestBatch.features)
let firstTestBatchPredictions = firstTestBatchLogits.argmax(squeezingAxis: 1)

print(firstTestBatchPredictions)
print(firstTestBatch.labels)
[1, 2, 0, 1, 1, 1, 0, 2, 1, 2, 2, 0, 2, 1, 1, 0, 1, 0, 0, 2, 0, 1, 2, 2, 1, 1, 0, 1, 2, 1]
[1, 2, 0, 1, 1, 1, 0, 2, 1, 2, 2, 0, 2, 1, 1, 0, 1, 0, 0, 2, 0, 1, 2, 1, 1, 1, 0, 1, 2, 1]

पूर्वानुमान बनाने के लिए प्रशिक्षित मॉडल का उपयोग करें

हमने एक मॉडल को प्रशिक्षित किया है और प्रदर्शित किया है कि यह अच्छा है - लेकिन सही नहीं है - आईरिस प्रजातियों को वर्गीकृत करने में। अब आइए गैर-सूचीबद्ध उदाहरणों पर कुछ पूर्वानुमान बनाने के लिए प्रशिक्षित मॉडल का उपयोग करें; यह उन उदाहरणों पर है जिनमें विशेषताएँ हैं लेकिन लेबल नहीं है।

वास्तविक जीवन में, अनलिस्टेड उदाहरण कई अलग-अलग स्रोतों से आ सकते हैं जिनमें ऐप, सीएसवी फाइलें और डेटा फीड शामिल हैं। अभी के लिए, हम उनके लेबल का अनुमान लगाने के लिए तीन अनलेब किए गए उदाहरणों को मैन्युअल रूप से प्रदान करने जा रहे हैं। स्मरण करो, लेबल नंबरों को नामांकित प्रतिनिधित्व के रूप में मैप किया जाता है:

  • 0 : आइरिस सेटोसा
  • 1 : आइरिस वर्सिकलर
  • 2 : आइरिस वर्जिनिका
let unlabeledDataset: Tensor<Float> =
    [[5.1, 3.3, 1.7, 0.5],
     [5.9, 3.0, 4.2, 1.5],
     [6.9, 3.1, 5.4, 2.1]]

let unlabeledDatasetPredictions = model(unlabeledDataset)

for i in 0..<unlabeledDatasetPredictions.shape[0] {
    let logits = unlabeledDatasetPredictions[i]
    let classIdx = logits.argmax().scalar!
    print("Example \(i) prediction: \(classNames[Int(classIdx)]) (\(softmax(logits)))")
}
Example 0 prediction: Iris setosa ([    0.9872727,  0.0124736205, 0.00025379486])
Example 1 prediction: Iris versicolor ([0.0026452888,     0.973102,  0.024252668])
Example 2 prediction: Iris virginica ([9.066205e-05,    0.0736953,    0.9262141])

एक अनुकूलक बनाएँ

एक ऑप्टिमाइज़र loss फ़ंक्शन को कम करने के लिए मॉडल के चर पर गणना किए गए ग्रेडिएंट्स को लागू करता है। आप नुकसान के कार्य को घुमावदार सतह के रूप में देख सकते हैं (चित्र 3 देखें) और हम चारों ओर घूमकर इसका निम्नतम बिंदु खोजना चाहते हैं। ग्रेडिएंट सबसे तेज चढ़ाई की दिशा में इंगित करता है - इसलिए हम विपरीत रास्ते की यात्रा करेंगे और पहाड़ी से नीचे जाएंगे। प्रत्येक बैच के लिए हानि और ढाल की गणना करके, हम प्रशिक्षण के दौरान मॉडल को समायोजित करेंगे। धीरे-धीरे, मॉडल को नुकसान को कम करने के लिए वजन और पूर्वाग्रह का सबसे अच्छा संयोजन मिलेगा। और नुकसान कम, बेहतर मॉडल की भविष्यवाणियां।

3 डी अंतरिक्ष में समय के साथ अनुकूलन एल्गोरिदम कल्पना।
चित्रा 3. 3 डी अंतरिक्ष में समय के साथ अनुकूलन एल्गोरिदम कल्पना।
(स्रोत: स्टैनफोर्ड क्लास CS231n , MIT लाइसेंस, छवि क्रेडिट: एलेक रेडफोर्ड )

TensorFlow के लिए स्विफ्ट में प्रशिक्षण के लिए कई अनुकूलन एल्गोरिदम उपलब्ध हैं। यह मॉडल डब्ल्यूडब्ल्यूडी ऑप्टिमाइज़र का उपयोग करता है जो स्टोचस्टिक ग्रेडिएंट वंश (डब्ल्यूडब्ल्यूडी) एल्गोरिथ्म को लागू करता है। learningRate पहाड़ी के नीचे प्रत्येक पुनरावृत्ति के लिए कदम आकार निर्धारित करता है। यह एक हाइपरपैरमीटर है जिसे आप आमतौर पर बेहतर परिणाम प्राप्त करने के लिए समायोजित करेंगे।