import numpy as np
# আমাদের প্রেডিকশন করার জন্য ডেটা পয়েন্ট, ছবির সাথে মিলিয়ে দেখুন
input_data = np.array([2, 3])
# আমাদের ডিকশনারী
weights = {'node_0': np.array([1, 1]),
'node_1': np.array([-1, 1]),
'output': np.array([2, -1])
}
# node 0 এর ভ্যালু ক্যালকুলেট করি: node_0_value
node_0_value = (input_data * weights['node_0']).sum()
# node ১ এর ভ্যালু ক্যালকুলেট করি: node_1_value
node_1_value = (input_data * weights['node_1']).sum()
# নোডগুলোর ভ্য়ালুগুলোকে অ্যারেতে রাখি: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_value, node_1_value])
# আউটপুট ক্যালকুলেট করি: output
output = (hidden_layer_outputs * weights['output']).sum()
# আউটপুট প্রিন্ট করে দেখি
print(hidden_layer_outputs)
print(output)
[5 1] 9
# নতুন ওয়েট এবং ইনপুট ডেটা
weights = np.array([1, 2])
input_data = np.array([3, 4])
# প্রেডিকশন ক্যাল্কুলেট করি: preds
preds = (weights * input_data).sum()
# ধরি আমাদের টার্গেট ৬
target = 6
# এরর ক্যালকুলেট করি: error
error = preds - target
# স্লোপ ক্যালকুলেট করি: slope
slope = 2 * input_data * error
# স্লোপ প্রিন্ট করি
print(slope)
[30 40]
# লার্নিং রেট ঠিক করি: learning_rate
learning_rate = 0.01
# স্লোপ/গ্রেডিয়েন্ট ক্যালকুলেট করি: gradient
gradient = 2 * input_data * error
# ওয়েট আপডেট করি: weights_updated
weights_updated = weights - learning_rate * gradient
# প্রেডিকশন আপডেট নেই : preds_updated
preds_updated = (weights_updated * input_data).sum()
# এররের আপডেট নেই: error_updated
error_updated = preds_updated - target
# শুরুর এরর প্রিন্ট করি
print(error)
# নতুন এরর প্রিন্ট করি
print(error_updated)
5 2.5
import numpy as np
# আমাদের প্রেডিকশন করার জন্য ডেটা পয়েন্ট, ছবির সাথে মিলিয়ে দেখুন
input_data = np.array([0, 3])
# স্যাম্পল ওয়েট যা পাল্টে দিয়েছি আমরা
weights_0 = {'node_0': [2, 1],
'node_1': [1, 2],
'output': [1, 1]
}
# আসল টার্গেট ভ্যালু, এরর বের করার জন্য লাগবে
target_actual = 3
# দুটো মেথড ডিফাইন করি
def relu(input):
output = max(0, input)
return output
def predict_with_network(input_data_row, weights):
node_0_input = (input_data_row * weights['node_0']).sum()
# print(node_0_input)
node_0_output = relu(node_0_input)
# print(node_0_output)
node_1_input = (input_data_row * weights['node_1']).sum()
node_1_output = relu(node_1_input)
hidden_layer_outputs = np.array([node_0_output, node_1_output])
input_to_final_layer = (hidden_layer_outputs * weights['output']).sum()
model_output = relu(input_to_final_layer)
return model_output
# শুরুর ওয়েট দিয়ে প্রেডিকশন করি
model_output_0 = predict_with_network(input_data, weights_0)
# এরর ক্যালকুলেট করি: error_0
error_0 = model_output_0 - target_actual
# নতুন ওয়েট দেই যাতে টার্গেট প্রেডিকশন (3) ধরতে পারে: weights_1
weights_1 = {'node_0': [2, 1],
'node_1': [1, 2],
'output': [1, 0]
}
# নতুন ওয়েট দিয়ে প্রেডিকশন: model_output_1
model_output_1 = predict_with_network(input_data, weights_1)
# আবার এরর ক্যালকুলেট করি: error_1
error_1 = model_output_1 - target_actual
# সবকিছু প্রিন্ট করে দেখি
print(model_output_0)
print(model_output_1)
print(error_0)
print(error_1)
9 3 6 0
import numpy as np
# আমাদের প্রেডিকশন করার জন্য ডেটা পয়েন্ট, ছবির সাথে মিলিয়ে দেখুন
input_data = np.array([-1, 2])
# আমাদের ডিকশনারী
weights = {'node_0': np.array([3, 3]),
'node_1': np.array([1, 5]),
'output': np.array([2, -1])
}
def relu(input):
'''রেল্যু ফাংশনকে ডিফাইন করে দিচ্ছি এখানে'''
# ইনপুটে যা পাবো সেটাকে ম্যাক্সিমাম যা আসবে, অথবা ঋনাত্বক আসলে "০" : output
output = max(0, input)
# Return the value just calculated
return(output)
# নোড ১ এর ভ্যালু ক্যালকুলেট করি: node_0_output
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = relu(node_0_input)
# নোড ২ এর ভ্যালু ক্যালকুলেট করি: node_1_output
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = relu(node_1_input)
# নতুন ভ্যালুগুলোকে অ্যারেতে বসাই: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])
# মডেলের আউটপুট ক্যালকুলেট করি (রেল্যুকে সরাসরি ব্যবহার না করে)
model_output = (hidden_layer_outputs * weights['output']).sum()
# Print model output
print(node_0_output)
print(node_1_output)
print(hidden_layer_outputs)
print(model_output)
3 9 [3 9] -3