Function ও Lambda

Pure function — functional programming-এর soul। Side-effect-এর বিরুদ্ধে discipline।

Pure function-এর দু'টি শর্ত:

• Same input → same output (deterministic)।
• No side-effect — global state পরিবর্তন নেই, file/network/print নেই।

উদাহরণ:

# Pure
def add(a, b):
    return a + b

# Impure — side effect
counter = 0
def add_with_log(a, b):
    global counter
    counter += 1
    print(f"Call #{counter}")
    return a + b

Pure function-এর সুবিধা:

• Testing সহজ: input দিলে output predictable। mock-এর দরকার নেই।
• Parallelizable: shared state নেই → race condition নেই।
• Memoizable: input → output cache করা যায়।
• Composable: f(g(h(x))) safe।
• Reasoning সহজ: "এই function এই input-এ কী করবে?" — predict possible।

AI/ML-এ এর তাৎপর্য:

• Reproducibility: impure code → run-to-run different। ML paper-এ disaster।
• Distributed training: Spark, Ray, JAX — pure function জরুরি।
• JAX-এর JIT: pure function compile করে XLA-তে। Impure → silent bug।
• Auto-differentiation: gradient হিসাব pure function ছাড়া meaningful নয়।

ML-এ অপরিহার্য impurity:

• Logging — print, MLflow।
• Random seed — সঠিকভাবে seed control করা।
• GPU state — tensor moves, memory allocation।
• File I/O — checkpoint save।

সমাধান — boundary-তে impurity:

• "Functional core, imperative shell" — Gary Bernhardt।
• Computation pure, I/O outside।
• Unit test pure core। Integration test shell।

Random এর কী হবে?

# Impure — hidden state
def augment(image):
    return image + np.random.randn()    # ভিন্ন run, ভিন্ন result

# Pure — explicit randomness
def augment(image, rng):
    return image + rng.randn()

JAX এই philosophy-র champion — explicit PRNG key।

Side-effect-এর তালিকা:

• Global variable মুটেট।
• Argument mutate (list.append)।
• File/network/db read/write।
• print, logging।
• Time, random — hidden input।
• Exception raise (debatable)।

মূল উপলব্ধি: 100% pure code unrealistic। কিন্তু purity discipline = 90% bug elimination। AI engineer-এর জন্য — function-কে pure যথাসম্ভব রাখুন। Impurity boundary-তে contained। JAX-এর rise এই philosophy-র victory।

এই bug — Python-এর সবচেয়ে famous gotcha। প্রায় সব Python developer একবার করেছে। বুঝলে — চিরকাল বাঁচা।

সমস্যা:

def append_item(item, target=[]):
    target.append(item)
    return target

print(append_item("a"))    # ['a']
print(append_item("b"))    # ['a', 'b'] — কেন?!
print(append_item("c"))    # ['a', 'b', 'c']

কারণ:

• Default argument function definition-এর সময় একবার evaluate হয়।
• Function object-এর সাথে bind — পরের call-এ একই list।
• Mutable হলে — append/modify shared।

সঠিক সমাধান — Sentinel pattern:

def append_item(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

AI কোডে এর প্রকাশ:

# খারাপ — একই config sharing
def train_model(name, history={}):
    history[name] = {"loss": []}
    return history

train_model("BERT")
train_model("GPT")    # BERT-এর history-ও সাথে!

• Hyperparameter dict: default mutable → পুরনো run-এর leak।
• Cache dict: function-call-এ cache shared (অনিচ্ছাকৃত)।
• List of metrics: training run-এ data leak।
• NumPy array default: একই reference, modification carry over।

কখন intentional?

• Memoization (functools.lru_cache ভাল)।
• Singleton state — global-এর alternative। Anti-pattern।

Type-checker সাহায্য:

• mypy/pyright warn — mutable default detect।
• ruff B006 rule — auto-detect।
• CI-তে এই lint চালান।

Default best practices:

• Mutable default → None + body-তে check।
• Immutable (int, str, tuple, frozenset) → safe।
• Type hint: list[int] | None = None

একটি advanced trick — frozen default:

from types import MappingProxyType

DEFAULT_CFG = MappingProxyType({"lr": 0.001})

def train(cfg=DEFAULT_CFG):
    # cfg.update(...)   # ← TypeError, immutable
    new_cfg = {**cfg, "epochs": 10}    # safe

মূল উপলব্ধি: Mutable default = time bomb। প্রথমবার কাজ করে, পরে কামড় দেয়। AI-তে — config, history, cache — খুব common surface। Sentinel pattern + linter = সমাধান।

Lambda Python-এ controversial। PEP 8 সাবধানে style guide দেয়। ভালো ব্যবহার — শক্তি; বেশি ব্যবহার — অস্পষ্টতা।

Lambda-র সীমা:

• Single expression — if/for/try নেই (ternary OK)।
• No statement — assignment, print নেই।
• Default name <lambda> — stack trace-এ অস্পষ্ট।
• No docstring।

Anti-pattern: lambda assign করা:

# খারাপ — PEP 8 violation
square = lambda x: x * x

# ভাল — def
def square(x):
    return x * x

কেন? def name দেয়, traceback ভাল, debugger-এ ভাল, docstring লেখা যায়।

Lambda কোথায় idiomatic:

• sorted() key:

  students.sort(key=lambda s: s.score)

• map/filter:

  list(map(lambda x: x ** 2, nums))

  (যদিও list comprehension প্রায় সবসময় ভাল)
• Pandas apply:

  df["upper"] = df["name"].apply(lambda s: s.upper())

• GUI callback:

  button.on_click(lambda: print("clicked"))

• functools.reduce:

  reduce(lambda a, b: a * b, nums)

AI/ML-এ lambda-র জায়গা:

• scikit-learn FunctionTransformer:

  from sklearn.preprocessing import FunctionTransformer
  log_tf = FunctionTransformer(lambda X: np.log1p(X))

• PyTorch Lambda layer:

  nn.Sequential(
      nn.Linear(10, 20),
      nn.ReLU(),
      nn.Lambda(lambda x: x * 2)    # custom op
  )

• DataFrame transformations: column-wise quick op।
• Sorting model checkpoints: sorted(paths, key=lambda p: int(p.stem.split('-')[-1]))।

Lambda-র alternatives:

• operator module:

  from operator import attrgetter, itemgetter
  sorted(students, key=attrgetter("score"))    # দ্রুত, পরিষ্কার
  sorted(items, key=itemgetter(1))

• functools.partial:

  from functools import partial
  double = partial(multiply, 2)    # multiply(2, x)

• List comprehension:

  [x ** 2 for x in nums]    # map+lambda-এর চেয়ে Pythonic

সিদ্ধান্তের সূত্র:

• One-time, in-place, simple → lambda OK।
• Reusable, named, complex → def।
• Side-effect, multi-line → অবশ্যই def।
• Existing equivalent (operator, partial) → use that।

মূল উপলব্ধি: Lambda = scalpel, not hammer। নির্দিষ্ট কাজে চমৎকার, সাধারণ কাজে def। PyTorch/Pandas-এ দরকারি tool, কিন্তু overuse code-কে obscure করে। "Will I read this in 6 months?" — উত্তর "না" হলে — def।

Decorator — Python-এর সবচেয়ে elegant feature-এর একটি। PEP 318 (২০০৩)-এ আসে। AI library design-এ কেন্দ্রীয়।

মূল ধারণা:

• Function-কে input হিসেবে নেয়, modified function ফেরত দেয়।
• @decorator = syntactic sugar for func = decorator(func)।
• "Behavior wrap"— original function-এ before/after logic।

মৌলিক উদাহরণ:

def timer(func):
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time()-start:.4f}s")
        return result
    return wrapper

@timer
def slow_op():
    sum(i**2 for i in range(10**6))

slow_op()    # auto-print timing

AI/ML-এ decorator-এর প্রভাব:

• @torch.no_grad(): Inference-এ gradient disable। Memory ৫০% সাশ্রয়।

  @torch.no_grad()
  def predict(model, x):
      return model(x)

• @jit.script (TorchScript): Python function → optimized graph।
• @tf.function: TensorFlow eager → graph mode।
• @jax.jit: XLA compilation, ১০-১০০× speedup।
• @cache / @lru_cache: Memoization — repeated computation এড়াতে।
• @dataclass: Auto-generate __init__, __repr__।
• @property: Method → attribute-like access।
• @app.route("/predict"): Flask/FastAPI — endpoint registration।

Decorator with arguments:

def retry(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(times):
                try:
                    return func(*args, **kwargs)
                except Exception:
                    if i == times - 1: raise
        return wrapper
    return decorator

@retry(times=3)
def fetch_data():
    ...

Class decorator vs function decorator:

• Class — state রাখা যায়। যেমন: counter, cache।
• Function — stateless wrap।
• functools.wraps — original metadata preserve।

Decorator stacking:

@cache
@validate_input
@log_calls
def expensive_op(x):
    ...
# expensive_op = cache(validate_input(log_calls(expensive_op)))

• নিচ থেকে উপরের দিকে apply — order matters।

সমস্যা ও সাবধানতা:

• functools.wraps ছাড়া — original name, docstring lost।
• Stack trace জটিল হয়।
• Type hint preservation কঠিন (Python 3.12-এ ParamSpec ভাল)।
• Debugger step-into through wrapper।

Built-in important decorators:

• @staticmethod, @classmethod — class methods।
• @property — getter।
• @functools.cache (3.9+) — simple memoization।
• @functools.wraps — meta preserve।
• @contextlib.contextmanager — with-statement।

মূল উপলব্ধি: Decorator = behavior modification declarative। AI library-তে — boilerplate কমানোর primary tool। @torch.no_grad() না বুঝলে — PyTorch inference loop confusing। Decorator master হলে — Python-এর সৌন্দর্য full বুঝবেন।