ورود به دنیای هوش مصنوعی | جلسه‌ی ۴ | برنامه‌نویسی پایتون؛ گرادیان کاهشی

Main ideas and lessons (Session 4: Python + foundations of ML)

1) Recap of prior machine learning concepts (datasets, labels, tasks)

• Dataset concept

  • A dataset is central to training AI models.

• Features vs. labels

  • Features: the input attributes you use for prediction (e.g., house area, construction year, number of rooms).
  • Label: the target you want to predict (e.g., house price).
  • Example (medical)
    • Radiology image = feature
    • Healthy vs. sick status = label (labeled pixel-by-pixel)

• Types of labels

  • Continuous labels → use regression
    • Examples: height measurements (numbers across a range).
  • Discrete labels → use classification
    • Examples: dog vs. cat, sick vs. healthy, offensive vs. polite.

• Model form and flexibility

  • Models can be:
    • Linear (e.g., a simple line: (a x + b))
    • Polynomial (higher degree adds flexibility)
  • Increasing polynomial degree increases flexibility but can raise the risk of overfitting.

• Parameters vs. hyperparameters

  • Parameters: learned weights inside the model.
  • Hyperparameters: choices that affect the model before learning (e.g., number of neurons, model degree).

• Loss / cost function (error to minimize)

  • Goal: adjust model so prediction error is minimized.
  • Error can be defined via:
    • Mean squared error
    • Mean absolute error

• Memorization vs. generalization

  • Memorization: model performs well only on training data, fails on new data.
  • Generalizable (repeatable) model: works on unseen data.

---

2) Measuring generalization correctly (data splitting + leakage)

• Split dataset into three parts:

  • Training set: e.g., 70 samples → used to learn parameters
  • Validation set: e.g., 10 samples → used to select best hyperparameters
  • Test set: e.g., 20 samples → used at the end to evaluate final performance

• Data leakage

  • If the test data (or information from it) accidentally influences training/selection, accuracy becomes misleading.
  • Example described:
    • With leakage: accuracy ~90%
    • After removing leakage: accuracy drops significantly (~60/90), showing poor true generalization.

---

3) Overfitting and underfitting

• Overfitting

  • Model becomes too flexible and memorizes training patterns/noise.
  • Performs poorly on validation/test data.

• Underfitting

  • Model is too simple to capture the underlying pattern.
  • Training error remains high and generalization suffers.

• Balance needed

  • Too few parameters → underfitting
  • Too many parameters → overfitting

---

Gradient descent methodology (coded later; conceptual algorithm described)

4) Core question: how do we find the “best parameters”?

• Analogy: hiking through fog/mountains
  • You can only “see” locally (short distance).
  • You move in the direction that reduces error (loss).
• Key idea:
  • Start with random parameter values.
  • Compute loss function value at current parameters.
  • Use derivative/gradient to decide the direction to move.
  • Repeat until reaching a minimum of the loss function.

5) Directions: gradient and derivative meaning

• If the loss function slope/derivative is:
  • Positive: moving forward increases loss → so move in the opposite direction (decrease parameter).
  • Negative: moving forward decreases loss → so again move in the opposite direction of the gradient to reduce loss.
• In multiple dimensions:
  • Gradient points where loss increases fastest.
  • So gradient descent moves against the gradient.

6) Step size: learning rate + tradeoffs

• Learning rate controls stride length.
• If learning rate is:
  • Too small: converges very slowly (may require a huge number of steps).
  • Too large: overshoots the minimum and may diverge or bounce around.
• This is the key practical knob to control convergence behavior.

7) Parameter update rule (gradient descent)

• General conceptual update:
  • New parameters = old parameters − learning_rate × gradient
• Repeat:
  • Compute gradient at current parameters
  • Update parameters
  • Continue until loss stops decreasing (minimum reached)

---

Python preparation: what the instructor teaches in this session (with actionable coding concepts)

8) Where to get materials and run code

• Uses GitHub for course resources:
  • A repository/folder for “Session 4”
  • Includes a dataset (CSV) and Jupyter notebooks
• Uses Google Colab (cloud notebook platform) to run notebooks:
  • Upload/download notebooks
  • Run code cells on Google’s servers
• Notes about Iran restrictions:
  • Some Google services may require a VPN to access.
  • Instructor does not endorse a specific VPN and warns about responsibility.

9) Jupyter Notebook structure

• Two main cell types:
  • Text cells: explanation
  • Code cells: Python execution
• Code runs on the cloud (Google server), not on the local computer.
• Emphasis:
  • You must practice by executing cells; watching alone isn’t enough.

10) Python basics taught (variables, types, syntax, control flow, functions)

Variables and data types

• Examples:
  • int (integer)
  • float (real/decimal number)
  • str (string/text)
• Strings must be inside quotes.
• Python is case-sensitive:
  • print must be lowercase.
  • Variable names must match exactly.
• If you use an undefined name, Python raises errors; the instructor demonstrates debugging by correcting names.

Output and expressions

• Demonstrates:
  • print(variable)
  • Mathematical expressions with precedence:
    • Multiplication/division before addition/subtraction
• Power operator:
  • Use ** for exponentiation (e.g., 2**5).

Syntax pitfalls

• Spaces/syntax errors can break code.
• He recommends using AI tools (e.g., Gemini/ChatGPT-style tools) to paste code + error message for explanation and fixes.

Lists and indexing

• Creating lists:
  • Define a list with multiple values separated by commas inside brackets.
• Indexing:
  • Starts at 0
  • Negative indices count from the end (e.g., -1 is the last element)
• Accessing an element:
  • list_name[0] to access the first element

Loops: for

• Iterating over list elements or ranges:
  • Example concept: for ... in range(...)
• Range behavior:
  • range(a, b) goes up to but does not include b.

Conditional logic: if

• Demonstrates:
  • if condition: ...
  • elif ...
  • else ...
• Example:
  • Age thresholds (prints “young” or “old” based on comparisons)
• Comparison operators:
  • <, <=, >, etc.
• Indentation is mandatory:
  • Python uses indentation to define block scope.
  • Tab can help with indentation.

Functions

• Define a function using:
  • def function_name(input):
  • Ends with :
• Function body can:
  • Print results
  • Or return values using return
• Printing vs. returning:
  • If a function returns something, you can assign/use it.
  • If it only prints, it may return nothing (often None).

Factorial exercise (implemented as a function)

• Creates a factorial function using:
  • A loop over range(1, n+1) (conceptually)
  • Multiplying an accumulator variable each step
• Factorial grows extremely fast (mentions huge values like 100! and 1000! scale comparisons).

---

Closing and motivation

• The instructor tells learners to:
  • Use the provided notebook
  • Run cells sequentially
  • Practice before the next session
• Next session promise:
  • More detailed machine learning coding
  • Applying these Python/ML foundations into ML tasks

---

Speakers / sources featured

• Primary speaker/instructor (unnamed in subtitles): the course host/teacher (references to “me” and course identity).
• Course/brand reference: “Sharifizar… / Sharifzarchi” (official account name for Telegram/Twitter/LinkedIn; says YouTube is the real channel).
• AI tools mentioned as examples: Gemini, ChatGPT (for debugging code).
• Platforms/sources referenced:
  • GitHub (code repository hosting)
  • Google Colab / Google “Club” (cloud notebook execution)
• No other distinct named speaker voices appear besides the instructor’s narration and acknowledgements/dedications.