समस्या
ग्रेडिएंट डिसेंट ग्रेडिएंट की उल्टी दिशा में चलकर वेट को थोड़ा-थोड़ा बेहतर बनाता है:
w ← w - learning_rate × dL/dw
स्टोकेस्टिक ग्रेडिएंट डिसेंट से एक sigmoid न्यूरॉन को ट्रेन करें। हर epoch में सैंपलों को दिए गए क्रम में लें, और हर सैंपल के लिए:
- z = sample · weights + bias, y = 1 / (1 + e^(-z))
- delta = 2 × (y - target) × y × (1 - y)
- weights[i] ← weights[i] - learning_rate × delta × sample[i] (हर i के लिए), फिर bias ← bias - learning_rate × delta
train_neuron(samples, targets, weights, bias, learning_rate, epochs) लागू करें।
इनपुट
samples: m ट्रेनिंग उदाहरण, हर एक में n मान।
targets: m सही आउटपुट (0 और 1 के बीच)।
weights, bias: शुरुआती वेट (n मान) और बायस।
learning_rate, epochs: स्टेप का आकार और डेटा पर कितनी बार चलना है।
आउटपुट
ट्रेन किए गए वेट और उनके बाद ट्रेन किया गया बायस लौटाएँ (n + 1 संख्याएँ)।
सीमाएँ
1 ≤ m ≤ 50, 1 ≤ n ≤ 10, 1 ≤ epochs ≤ 1,000
0 < learning_rate ≤ 5
-5 ≤ हर मान ≤ 5
उदाहरण
इनपुट:
bias = 0.0
epochs = 1
samples = [
[1.0]
]
targets = [1.0]
weights = [0.0]
learning_rate = 1.0
अपेक्षित आउटपुट:
expected = [0.25, 0.25]इनपुट:
double bias = 0.0;
long long epochs = 1;
std::vector<std::vector<double>> samples = {
{1.0}
};
std::vector<double> targets = {1.0};
std::vector<double> weights = {0.0};
double learning_rate = 1.0;
अपेक्षित आउटपुट:
std::vector<double> expected = {0.25, 0.25};इनपुट:
double bias = 0.0;
long epochs = 1;
double[][] samples = new double[][] {
new double[] {1.0}
};
double[] targets = new double[] {1.0};
double[] weights = new double[] {0.0};
double learning_rate = 1.0;
अपेक्षित आउटपुट:
double[] expected = new double[] {0.25, 0.25};व्याख्या
y = σ(0) = 0.5, delta = 2 × (0.5 - 1) × 0.25 = -0.25। वेट: 0 - 1 × (-0.25) × 1 = 0.25। बायस: 0 - 1 × (-0.25) = 0.25। परिणाम: [0.25, 0.25]।
इनपुट:
bias = 0.0
epochs = 500
samples = [
[0.0, 0.0],
[0.0, 1.0],
[1.0, 0.0],
[1.0, 1.0]
]
targets = [0.0, 0.0, 0.0, 1.0]
weights = [0.0, 0.0]
learning_rate = 2.0
अपेक्षित आउटपुट:
expected = [6.346558, 6.339863, -9.592092]इनपुट:
double bias = 0.0;
long long epochs = 500;
std::vector<std::vector<double>> samples = {
{0.0, 0.0},
{0.0, 1.0},
{1.0, 0.0},
{1.0, 1.0}
};
std::vector<double> targets = {0.0, 0.0, 0.0, 1.0};
std::vector<double> weights = {0.0, 0.0};
double learning_rate = 2.0;
अपेक्षित आउटपुट:
std::vector<double> expected = {6.346558, 6.339863, -9.592092};इनपुट:
double bias = 0.0;
long epochs = 500;
double[][] samples = new double[][] {
new double[] {0.0, 0.0},
new double[] {0.0, 1.0},
new double[] {1.0, 0.0},
new double[] {1.0, 1.0}
};
double[] targets = new double[] {0.0, 0.0, 0.0, 1.0};
double[] weights = new double[] {0.0, 0.0};
double learning_rate = 2.0;
अपेक्षित आउटपुट:
double[] expected = new double[] {6.346558, 6.339863, -9.592092};व्याख्या
यह लॉजिकल AND गेट है। 500 epoch के बाद दोनों वेट बड़े और धनात्मक हो जाते हैं और बायस काफ़ी ऋणात्मक, इसलिए केवल इनपुट [1, 1] का आउटपुट 0.5 से ज़्यादा होता है।
कैसे हल करें
पहले खुद कोशिश करें, फिर एक-एक करके संकेत खोलें।
संकेत 1
हर epoch में training samples को क्रम से process करें, और हर example के बाद weights तुरंत update करें.
संकेत 2
हर sample के लिए sigmoid output निकालें, फिर उसके gradient से weights और bias को downhill move करें.
संकेत 3
क्योंकि updates online हैं, एक ही epoch में बाद वाले samples पहले हुए updates देखेंगे.
अपेक्षित जटिलता
समय O(epochs × m × n), अतिरिक्त स्थान O(1)
संदर्भ
यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।