Traditional ML Algorithms Explained | Linear Regression, Decision Trees Sinhala

අපි හැමෝම Artificial Intelligence (AI) සහ Large Language Models (LLMs) ගැන මේ දවස්වල කතා කරනවා, නේද? ChatGPT, Bard, Llama වගේ දේවල් නිසා AI ලෝකය අලුත් පැත්තකට ගිහින්. ඒත්, මේ අලුත් තාක්ෂණයන් ආවත්, Traditional Machine Learning Algorithms කියන දේවල් තවමත් අපිට නැතුවම බැරි වැදගත් මෙවලම් ටිකක්.

අද අපි මේ tutorial එකෙන් බලමු AI යුගයේදීත් Traditional ML Algorithms ඇයි මෙච්චර වැදගත් කියලා, ඒ වගේම Linear Regression, Logistic Regression, Decision Trees, Random Forests වගේ මූලික Algorithms ටිකක් මොනවද, ඒවා කොහොමද වැඩ කරන්නේ කියලා සරලව තේරුම් ගනිමු. පොඩි Python code examples ටිකකුත් එක්ක අපි මේවා ප්‍රායෝගිකවම බලමු.

AI/LLM යුගයේ Traditional ML ඇයි වැදගත්?

හරි, දැන් ඔයා හිතයි, "ChatGPT වගේ දේවල් තියෙද්දි, අපි ඇයි මේ පරණ algorithms ගැන කතා කරන්නේ?" කියලා. ඒකට හේතු කිහිපයක් තියෙනවා. LLMs ගොඩක් දේවල් කරන්න පුළුවන් වුණත්, ඒවා හැම තැනටම සුදුසු නැහැ. සමහර වෙලාවට, Traditional ML Algorithms ඊට වඩා හොඳ විසඳුම් සපයනවා:

• වඩාත් පැහැදිලි බව (Interpretability): Traditional ML models ගොඩක් වෙලාවට 'කළු පෙට්ටි' වගේ නැහැ (black boxes). Decision Trees වගේ Algorithms වල ප්‍රතිඵල තේරුම් ගන්න, ඒ තීරණ වලට ආවේ කොහොමද කියලා පැහැදිලිව දකින්න පුළුවන්. ඒක medical diagnosis වගේ වැදගත් තීරණ ගන්න තැන්වලදී අත්‍යවශ්‍යයි.
• දත්ත ප්‍රමාණය (Data Efficiency): LLMs වලට පුහුණු වෙන්න අති විශාල දත්ත ප්‍රමාණයක් (petabytes of data) ඕනේ. ඒත් Traditional ML Algorithms වලට බොහෝ වෙලාවට කුඩා dataset එකකින් වුණත් හොඳ ප්‍රතිඵල ගන්න පුළුවන්. හැම වෙලාවෙම අපිට විශාල දත්ත ප්‍රමාණයක් එකතු කරන්න බැරි වෙන්න පුළුවන්, නේද?
• ප්‍රවේශවීමේ හැකියාව (Accessibility): Traditional ML models පුහුණු කරන්න සහ යොදවන්න LLMs තරම් විශාල ගණනය කිරීමේ බලයක් (computational power) අවශ්‍ය නැහැ. ඒ නිසා පොඩි පරිසරයක වුණත් මේවා implement කරන්න පහසුයි.
• නිශ්චිත කාර්යයන් (Specific Tasks): structured data (tables) වලින් numeric predictions හෝ classifications කරන්න Traditional ML Algorithms ගොඩක් කාර්යක්ෂමයි. උදාහරණයක් විදිහට, බැංකුවක loan approval එකක් දෙන්නද නැද්ද කියලා තීරණය කරන්න LLM එකක් පාවිච්චි කරනවට වඩා Logistic Regression model එකක් හොඳටම ප්‍රමාණවත්.

ඒ නිසා, අපි Traditional ML Algorithms තේරුම් ගැනීමෙන් AI ලෝකයේ වඩාත් හොඳට වැඩ කරන්නත්, නිවැරදි තැනට නිවැරදි මෙවලම තෝරගන්නත් පුළුවන් වෙනවා.

1. Linear Regression: සරලම පුරෝකථන ආකෘතිය

Linear Regression කියන්නේ Machine Learning වල තියෙන සරලම, ඒ වගේම ගොඩක් ප්‍රයෝජනවත් Algorithm එකක්. මේකෙන් කරන්නේ එක විචල්‍යයක් (variable) පාවිච්චි කරලා, තවත් විචල්‍යයක අගයක් පුරෝකථනය කරන එක. උදාහරණයක් විදිහට, ගෙදරක ප්‍රමාණය (square footage) අනුව ඒකෙ මිල පුරෝකථනය කරනවා වගේ දෙයක්.

කොහොමද වැඩ කරන්නේ?

මේ Algorithm එකේ මූලිකම අදහස තමයි, දත්ත ලක්ෂ්‍ය (data points) අතරින් හොඳම සරල රේඛාවක් (best fit line) ඇඳීම. මේ රේඛාවෙන් තමයි අපි අලුත් දත්ත ලක්ෂ්‍යයක අගය පුරෝකථනය කරන්නේ.

ගණිතමය වශයෙන් ගත්තොත්, මේක y = mx + c කියන සරල රේඛා සමීකරණය වගේ දෙයක්. මෙතනදී:

• y කියන්නේ අපි පුරෝකථනය කරන්න බලාපොරොත්තු වෙන අගය (dependent variable).
• x කියන්නේ පුරෝකථනයට පාවිච්චි කරන අගය (independent variable).
• m කියන්නේ රේඛාවේ බෑවුම (slope). x එකකින් වැඩි වෙනකොට y කොච්චරක් වෙනස් වෙනවද කියලා මේකෙන් කියනවා.
• c කියන්නේ y අක්ෂය කැපෙන තැන (y-intercept). x බිංදුව වුණාම y වල අගය.

Linear Regression model එකක් පුහුණු කරනවා කියන්නේ, මේ m සහ c කියන අගයන් අපේ දත්ත වලට ගැලපෙන විදිහට හොයාගන්න එක.

Linear Regression පාවිච්චි කරන අවස්ථා:

• නිවාස මිල ගණන් පුරෝකථනය කිරීම.
• විකුණුම් ප්‍රමාණයන් පුරෝකථනය කිරීම.
• කොටස් වෙළඳපොළේ මිල ගණන් පුරෝකථනය කිරීම (සරල ආකෘති).

Python උදාහරණය:

අපි හිතමු අපි ඩිග්‍රී එකේදී ඉගෙන ගත්ත පැය ගාන (Hours Studied) අනුව විභාගෙන් ගන්න පුළුවන් ලකුණු ප්‍රමාණය (Exam Score) පුරෝකථනය කරනවා කියලා. Python වල scikit-learn library එකෙන් මේක කොච්චර ලේසියෙන් කරන්න පුළුවන්ද බලන්න.

import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# Dummy දත්ත සකස් කරමු (Hours Studied vs. Exam Score)
hours_studied = np.array([2, 3, 4, 5, 6, 7, 8, 9, 10]).reshape(-1, 1)
exam_scores = np.array([55, 60, 65, 70, 75, 80, 85, 90, 95])

# Linear Regression model එකක් හදමු
model = LinearRegression()

# Model එක පුහුණු කරමු (Fit the model)
model.fit(hours_studied, exam_scores)

# අලුත් පැය ගානකට ලකුණු පුරෝකථනය කරමු
new_hours = np.array([[7.5]])
predicted_score = model.predict(new_hours)

print(f"පැය {new_hours[0][0]} ක් ඉගෙන ගත්තොත්, පුරෝකථනය කරන ලද ලකුණු: {predicted_score[0]:.2f}")
print(f"Slope (m): {model.coef_[0]:.2f}")
print(f"Y-intercept (c): {model.intercept_:.2f}")

# ප්‍රතිඵල visualize කරමු
plt.scatter(hours_studied, exam_scores, color='blue', label='Actual Scores')
plt.plot(hours_studied, model.predict(hours_studied), color='red', label='Regression Line')
plt.xlabel('ඉගෙන ගත් පැය ගණන (Hours Studied)')
plt.ylabel('විභාග ලකුණු (Exam Score)')
plt.title('පැය ගණනට විභාග ලකුණු පුරෝකථනය (Linear Regression)')
plt.legend()
plt.grid(True)
plt.show()

මේ code එක run කලාම, පැය ගාන වැඩි වෙනකොට ලකුණුත් වැඩි වෙනවා කියලා පෙන්නන සරල රේඛාවක් ලැබෙනවා. ඒ වගේම, ඔයා දෙන අලුත් පැය ගානකට ලකුණු ප්‍රමාණයක් පුරෝකථනය කරලා දෙනවා.

2. Logistic Regression: වර්ගීකරණයේ මුල්ම පියවර

Linear Regression අගයන් පුරෝකථනය කරනවා වගේ, Logistic Regression කරන්නේ වර්ගීකරණය (classification). මේකෙන් binary outcomes (ප්‍රතිඵල දෙකක්) තියෙන දේවල් පුරෝකථනය කරන්න පුළුවන්. උදාහරණයක් විදිහට, email එකක් spam ද නැද්ද, රෝගියෙකුට රෝගයක් තියෙනවද නැද්ද, customer කෙනෙක් product එකක් මිල දී ගනීවිද නැද්ද වගේ.

කොහොමද වැඩ කරන්නේ?

Linear Regression වලදී වගේ සරල රේඛාවක් අඳිනවට වඩා, Logistic Regression එකක් Sigmoid Function එකක් පාවිච්චි කරනවා. මේ function එකෙන් ඕනෑම අගයක් 0 ත් 1 ත් අතර අගයකට පරිවර්තනය කරනවා. මේ 0 ත් 1 ත් අතර අගය තමයි යම් සිද්ධියක් සිදුවීමේ සම්භාවිතාව (probability) විදිහට අපි ගන්නේ.

උදාහරණයක් විදිහට, 0.75 කියන්නේ 75% ක සම්භාවිතාවක්. 0.5 ට වඩා වැඩි නම් "ඔව්" (Yes) කියලත්, 0.5 ට වඩා අඩු නම් "නැහැ" (No) කියලත් අපි තීරණය කරන්න පුළුවන්. මේ 0.5 කියන අගයට අපි කියන්නේ Decision Boundary එක කියලා.

Logistic Regression පාවිච්චි කරන අවස්ථා:

• Spam email හඳුනාගැනීම.
• ණය අයදුම්කරුවන්ගේ default වීමේ අවදානම පුරෝකථනය කිරීම.
• රෝග විනිශ්චය (උදා: පිළිකා සෛල හඳුනාගැනීම).

Python උදාහරණය:

අපි හිතමු student කෙනෙක් study කරන පැය ගාන අනුව exam එකක් pass වෙනවද fail වෙනවද කියලා පුරෝකථනය කරනවා කියලා.

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Dummy දත්ත සකස් කරමු (Hours Studied vs. Pass/Fail)
hours_studied = np.array([0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5, 9, 9.5, 10]).reshape(-1, 1)
pass_fail = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) # 0 = Fail, 1 = Pass

# දත්ත පුහුණු සහ පරීක්ෂණ කට්ටලවලට වෙන් කරමු
X_train, X_test, y_train, y_test = train_test_split(hours_studied, pass_fail, test_size=0.3, random_state=42)

# Logistic Regression model එකක් හදමු
model = LogisticRegression()

# Model එක පුහුණු කරමු
model.fit(X_train, y_train)

# පුරෝකථනය කරමු
y_pred = model.predict(X_test)

print(f"Model Accuracy: {accuracy_score(y_test, y_pred):.2f}")

# අලුත් පැය ගානකට Pass/Fail පුරෝකථනය කරමු
new_hours = np.array([[3.2]])
prediction = model.predict(new_hours)
probability = model.predict_proba(new_hours)

if prediction[0] == 1:
    print(f"පැය {new_hours[0][0]} ක් ඉගෙන ගත්තොත්, පුරෝකථනය: Pass (සම්භාවිතාව: {probability[0][1]:.2f})")
else:
    print(f"පැය {new_hours[0][0]} ක් ඉගෙන ගත්තොත්, පුරෝකථනය: Fail (සම්භාවිතාව: {probability[0][0]:.2f})")

මෙතනදී, predict_proba කියන method එකෙන් ඔයාට ලැබෙනවා student කෙනෙක් pass වෙන්න තියෙන සම්භාවිතාව (probability) කීයද කියලා. ඒක 0.5 ට වැඩි නම් Pass, නැත්නම් Fail කියලා model එක තීරණය කරනවා.

3. Decision Trees: තීරණ ගන්නා ගස්

Decision Trees කියන්නේ නම වගේම, තීරණ ගන්න tree (ගසක්) වගේ ව්‍යුහයක්. මේක classification සහ regression දෙකටම පාවිච්චි කරන්න පුළුවන්. ඒක හරියට flowchart එකක් වගේ, එක එක ප්‍රශ්න අහ අහා අවසාන තීරණයට එළඹෙනවා.

කොහොමද වැඩ කරන්නේ?

Decision Tree එකක් දත්ත කට්ටලයක් (dataset) පොඩි පොඩි කොටස් වලට කඩනවා. මේවා nodes කියලා හඳුන්වනවා. හැම node එකකදීම යම්කිසි feature එකක් (විශේෂාංගයක්) මත පදනම්ව ප්‍රශ්නයක් අහනවා (උදා: "වයස 30ට වැඩිද?"). ඒ ප්‍රශ්නයට ලැබෙන උත්තරය අනුව, දත්ත තවදුරටත් බෙදෙනවා branches ඔස්සේ. අවසාන වශයෙන්, කිසිම බෙදීමක් නැති node එක leaf node එකක්. මේ leaf node එකේ තමයි අවසාන තීරණය (classification) හෝ අගය (regression) තියෙන්නේ.

ගසක් වගේ උඩින්ම තියෙන node එකට Root Node කියලා කියනවා.

Decision Trees වල වාසියක් තමයි ඒවා ගොඩක් පැහැදිලි (interpretable) වීම. මොකද ඔයාට tree එකේ පාර (path) දිගේ ගිහින් බලන්න පුළුවන් යම් තීරණයකට ආවේ කොහොමද කියලා.

Decision Trees පාවිච්චි කරන අවස්ථා:

• රෝග විනිශ්චය.
• බැංකු ණයක් අනුමත කිරීමේ තීරණ.
• Customer segmentation.

Python උදාහරණය:

අපි හිතමු අපි පුද්ගලයෙකුගේ ආදායම (Income) සහ වයස (Age) අනුව ඔහුට new car එකක් මිල දී ගැනීමට හැකියාව තිබේද (Can Buy Car) කියා පුරෝකථනය කරනවා කියලා.

import pandas as pd
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from io import StringIO
from IPython.display import Image
import pydotplus

# Dummy දත්ත සකස් කරමු
data = {
    'Income': [50000, 60000, 30000, 75000, 35000, 80000, 40000, 90000, 25000, 65000],
    'Age': [28, 35, 22, 45, 30, 50, 25, 48, 20, 40],
    'Can Buy Car': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] # 0 = No, 1 = Yes
}
df = pd.DataFrame(data)

X = df[['Income', 'Age']]
y = df['Can Buy Car']

# දත්ත පුහුණු සහ පරීක්ෂණ කට්ටලවලට වෙන් කරමු
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Decision Tree Classifier model එකක් හදමු
model = DecisionTreeClassifier()

# Model එක පුහුණු කරමු
model.fit(X_train, y_train)

# පුරෝකථනය කරමු
y_pred = model.predict(X_test)

print(f"Model Accuracy: {accuracy_score(y_test, y_pred):.2f}")

# අලුත් පුද්ගලයෙකුට පුරෝකථනය කරමු
new_person = pd.DataFrame({'Income': [55000], 'Age': [32]})
prediction = model.predict(new_person)

if prediction[0] == 1:
    print(f"ආදායම {new_person['Income'][0]} සහ වයස {new_person['Age'][0]} වන පුද්ගලයාට car එකක් ගන්න පුළුවන්.")
else:
    print(f"ආදායම {new_person['Income'][0]} සහ වයස {new_person['Age'][0]} වන පුද්ගලයාට car එකක් ගන්න බැහැ.")

# Decision Tree එක visualize කරමු (මෙය වැඩ කිරීමට Graphviz ස්ථාපනය කර තිබිය යුතුය)
# dot_data = StringIO()
# export_graphviz(model, out_file=dot_data,
#                 filled=True, rounded=True,
#                 special_characters=True, feature_names = ['Income', 'Age'],class_names=['No','Yes'])
# graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
# graph.write_png('decision_tree.png')
# Image(graph.create_png())

මේ code එකෙන්, model එකේ accuracy එක පෙන්නනවා වගේම, අලුත් පුද්ගලයෙකුට car එකක් මිලදී ගැනීමට හැකියාව තියෙනවද නැද්ද කියලා පුරෝකථනය කරනවා. Decision Tree එක visualize කරන්න Graphviz අවශ්‍යයි. ඒක install කරලා උඩ code එකේ comment කරලා තියෙන ටික uncomment කරලා බලන්න පුළුවන්.

4. Random Forests: ගස් ගොඩක බලය

Decision Trees තනිවම ගොඩක් හොඳ වුණත්, ඒවාට පොඩි දුර්වලතාවයක් තියෙනවා: overfitting. ඒ කියන්නේ model එක පුහුණු dataset එකට ඕනවට වඩා හොඳට ගැලපිලා, අලුත් දත්ත වලට හරියට වැඩ නොකර ඉන්න පුළුවන්.

මෙන්න මේකට විසඳුමක් විදිහට තමයි Random Forests එන්නේ. Random Forest එකක් කියන්නේ තනි Decision Tree එකකට වඩා ගොඩක් Decision Trees එකතු කරලා හදපු ensemble model එකක්. හරියට ගස් එකක් වෙනුවට, целый කැලයක් වගේ!

කොහොමද වැඩ කරන්නේ?

Random Forest එකක් ගොඩක් Decision Trees හදනවා. හැම tree එකක්ම පුහුණු කරන්නේ දත්ත කට්ටලයේ අහඹු උප-නියැදියක් (random subset) සහ features වල අහඹු උප-නියැදියක් පාවිච්චි කරලා. මේ ක්‍රියාවලියට කියන්නේ Bagging (Bootstrap Aggregating) කියලා.

අන්තිමට, යම්කිසි පුරෝකථනයක් කරන්න ඕන වුණාම, මේ හැම Decision Tree එකක්ම තමන්ගේ තීරණය දෙනවා. Classification එකක් නම්, වැඩිම trees ගණනක් කියන තීරණය (majority vote) තමයි Random Forest එකේ අවසාන තීරණය වෙන්නේ. Regression එකක් නම්, හැම tree එකකම පුරෝකථන වල සාමාන්‍යය (average) ගන්නවා.

මේ විදිහට ගොඩක් trees වල තීරණ එකතු කිරීමෙන් model එකේ නිරවද්‍යතාවය (accuracy) වැඩි වෙනවා වගේම, overfitting වීමේ අවදානම අඩු වෙනවා. ඒක හරියට expert ලා ගොඩක් දෙනෙක්ගෙන් අදහස් අරගෙන තීරණයක් ගන්නවා වගේ.

Random Forests පාවිච්චි කරන අවස්ථා:

• බැංකු fraud detection.
• රෝග විනිශ්චය (වඩාත් නිරවද්‍ය ලෙස).
• Stock market price prediction.

Python උදාහරණය:

අපි උඩින් පාවිච්චි කරපු 'Can Buy Car' dataset එකම පාවිච්චි කරමු, නමුත් මේ වතාවේ Random Forest එකක් යොදාගෙන.

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Dummy දත්ත (උඩින් තිබුණු Data Frame එකම)
data = {
    'Income': [50000, 60000, 30000, 75000, 35000, 80000, 40000, 90000, 25000, 65000],
    'Age': [28, 35, 22, 45, 30, 50, 25, 48, 20, 40],
    'Can Buy Car': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] # 0 = No, 1 = Yes
}
df = pd.DataFrame(data)

X = df[['Income', 'Age']]
y = df['Can Buy Car']

# දත්ත පුහුණු සහ පරීක්ෂණ කට්ටලවලට වෙන් කරමු
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Random Forest Classifier model එකක් හදමු
# n_estimators කියන්නේ අපි හදන trees ගාන
model = RandomForestClassifier(n_estimators=100, random_state=42)

# Model එක පුහුණු කරමු
model.fit(X_train, y_train)

# පුරෝකථනය කරමු
y_pred = model.predict(X_test)

print(f"Random Forest Model Accuracy: {accuracy_score(y_test, y_pred):.2f}")

# අලුත් පුද්ගලයෙකුට පුරෝකථනය කරමු
new_person_rf = pd.DataFrame({'Income': [55000], 'Age': [32]})
prediction_rf = model.predict(new_person_rf)

if prediction_rf[0] == 1:
    print(f"ආදායම {new_person_rf['Income'][0]} සහ වයස {new_person_rf['Age'][0]} වන පුද්ගලයාට Random Forest අනුව car එකක් ගන්න පුළුවන්.")
else:
    print(f"ආදායම {new_person_rf['Income'][0]} සහ වයස {new_person_rf['Age'][0]} වන පුද්ගලයාට Random Forest අනුව car එකක් ගන්න බැහැ.")

මේ උදාහරණයෙන් ඔයාට පෙනේවි Random Forest එකක් කොහොමද ක්‍රියා කරන්නේ කියලා. සාමාන්‍යයෙන්, Random Forest එකක් තනි Decision Tree එකකට වඩා හොඳ accuracy එකක් දෙනවා.

අමතරව: Support Vector Machines (SVM)

Traditional ML algorithms ගැන කතා කරනකොට Support Vector Machines (SVM) ගැනත් සඳහන් නොකරම බැහැ. SVM කියන්නේ classification සහ regression දෙකටම පාවිච්චි කරන්න පුළුවන්, ගොඩක් බලවත් Algorithm එකක්. මේකෙන් කරන්නේ dataset එකේ තියෙන classes දෙකක් (හෝ ඊට වැඩි) වෙන් කරන optimal hyperplane එකක් හොයාගන්න එක. Non-linear data තියෙන වෙලාවට kernel trick වගේ දේවල් පාවිච්චි කරලා, SVM වලට ගොඩක් සංකීර්ණ රටාත් හඳුනාගන්න පුළුවන්.

නිගමනය

බලන්න, AI/LLM යුගයේදීත් Traditional Machine Learning Algorithms කොච්චර වැදගත්ද කියලා? මේවා තමයි Machine Learning ලෝකයේ අපේ හොඳම යාළුවෝ. Linear Regression, Logistic Regression, Decision Trees, සහ Random Forests වගේ Algorithms වල මූලික සංකල්ප තේරුම් ගැනීමෙන්, ඔයාට ඕනෑම AI හෝ ML project එකකදී නිවැරදි තීරණ ගන්න පුළුවන් වෙනවා.

මතක තියාගන්න, හැම ප්‍රශ්නයකටම උත්තරය LLM එකක්ම වෙන්න ඕනේ නැහැ. සමහර වෙලාවට මේ පැරණි නමුත් බලවත් algorithms අපිට වඩා හොඳ, වඩාත් කාර්යක්ෂම සහ වඩාත් පැහැදිලි විසඳුම් ලබා දෙනවා.

දැන් ඉතින් ඔයාට පුළුවන් මේ Algorithms ගැන තවදුරටත් හොයලා බලන්න, මේ code examples ඔයාගේ පරිගණකයේ run කරලා බලන්න, ඒ වගේම ඔයාගේම data set එකක් අරගෙන මේ model ටික පුහුණු කරන්න. ඔයාගේ අත්දැකීම් කොහොමද කියලා පහළ comment section එකේ අපිට කියන්න! ඔයාට මේ ගැන මොනවා හරි ප්‍රශ්න තියෙනවා නම්, අහන්න පසුබට වෙන්න එපා. ඊළඟ tutorial එකකින් හමුවෙමු!