add logers

11 Indobert-base-p1_without_law.py

@@ -52,6 +52,7 @@ from pathlib import Path
 from pprint import pprint
 import matplotlib.pyplot as plt
 import seaborn as sns
+import logging
 
 import torch
 from datasets import load_dataset, Dataset, DatasetDict
@@ -113,6 +114,82 @@ def set_seed(seed: int):
 # Apply seed early so operations below are deterministic where possible
 set_seed(SEED)
 
+# ------------------------------------------------------------------
+# Logging setup: write console output and prints to a file in OUTPUT_DIR
+# This captures print() output by redirecting sys.stdout/stderr to the logger
+# ------------------------------------------------------------------
+import sys as _sys_for_logging
+
+# Ensure output dir exists so log file can be created early
+Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+log_file = Path(OUTPUT_DIR) / "run.log"
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s")
+
+# File handler (append)
+fh = logging.FileHandler(log_file, encoding='utf-8')
+fh.setLevel(logging.INFO)
+fh.setFormatter(formatter)
+logger.addHandler(fh)
+
+# Stream handler to keep console output (stdout)
+sh = logging.StreamHandler(_sys_for_logging.stdout)
+sh.setLevel(logging.INFO)
+sh.setFormatter(formatter)
+logger.addHandler(sh)
+
+# Helper to redirect prints to logger while still showing on console
+class _LoggerWriter:
+    """A lightweight wrapper forwarding writes to a logging function.
+
+    Exposes a minimal file-like interface expected by libraries that call
+    sys.stdout/sys.stderr methods such as .write(), .flush(), and .isatty().
+    """
+    def __init__(self, level_func):
+        self.level_func = level_func
+
+    def write(self, message):
+        if message is None:
+            return
+        if isinstance(message, (bytes, bytearray)):
+            try:
+                message = message.decode('utf-8', errors='replace')
+            except Exception:
+                message = str(message)
+
+        if message and message.strip() != "":
+            # Remove trailing newline added by print
+            self.level_func(message.rstrip("\n"))
+
+    def flush(self):
+        return
+
+    def isatty(self):
+        return False
+
+    @property
+    def encoding(self):
+        return getattr(_sys_for_logging.__stdout__, 'encoding', 'utf-8')
+
+    def fileno(self):
+        try:
+            return _sys_for_logging.__stdout__.fileno()
+        except Exception:
+            raise OSError("fileno() is not supported by _LoggerWriter")
+
+    def writable(self):
+        return True
+
+# Replace stdout/stderr so existing print() calls are captured in the log file
+_sys_for_logging.stdout = _sys_for_logging.__stdout__
+_sys_for_logging.stderr = _sys_for_logging.__stderr__
+_sys_for_logging.stdout = _LoggerWriter(logger.info)
+_sys_for_logging.stderr = _LoggerWriter(logger.error)
+sys.stdout = _sys_for_logging.stdout
+sys.stderr = _sys_for_logging.stderr
+
 # Hugging Face token (optional) - prefer setting this in your environment
 HF_TOKEN = os.environ.get('HF_TOKEN')  # Set HF_TOKEN environment variable
 

12 Indobert-base-p1_with_law.py

@@ -52,6 +52,7 @@ from pathlib import Path
 from pprint import pprint
 import matplotlib.pyplot as plt
 import seaborn as sns
+import logging
 
 import torch
 from datasets import load_dataset, Dataset, DatasetDict
@@ -113,6 +114,73 @@ def set_seed(seed: int):
 # Apply seed early so operations below are deterministic where possible
 set_seed(SEED)
 
+# ------------------------------------------------------------------
+# Logging setup: write console output and prints to a file in OUTPUT_DIR
+# This captures print() output by redirecting sys.stdout/stderr to the logger
+# ------------------------------------------------------------------
+import sys as _sys_for_logging
+
+# Ensure output dir exists so log file can be created early
+Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+log_file = Path(OUTPUT_DIR) / "run.log"
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s")
+
+# File handler (append)
+fh = logging.FileHandler(log_file, encoding='utf-8')
+fh.setLevel(logging.INFO)
+fh.setFormatter(formatter)
+logger.addHandler(fh)
+
+# Stream handler to keep console output (stdout)
+sh = logging.StreamHandler(_sys_for_logging.stdout)
+sh.setLevel(logging.INFO)
+sh.setFormatter(formatter)
+logger.addHandler(sh)
+
+class _LoggerWriter:
+    def __init__(self, level_func):
+        self.level_func = level_func
+
+    def write(self, message):
+        if message is None:
+            return
+        if isinstance(message, (bytes, bytearray)):
+            try:
+                message = message.decode('utf-8', errors='replace')
+            except Exception:
+                message = str(message)
+        if message and message.strip() != "":
+            self.level_func(message.rstrip("\n"))
+
+    def flush(self):
+        return
+
+    def isatty(self):
+        return False
+
+    @property
+    def encoding(self):
+        return getattr(_sys_for_logging.__stdout__, 'encoding', 'utf-8')
+
+    def fileno(self):
+        try:
+            return _sys_for_logging.__stdout__.fileno()
+        except Exception:
+            raise OSError("fileno() is not supported by _LoggerWriter")
+
+    def writable(self):
+        return True
+
+_sys_for_logging.stdout = _sys_for_logging.__stdout__
+_sys_for_logging.stderr = _sys_for_logging.__stderr__
+_sys_for_logging.stdout = _LoggerWriter(logger.info)
+_sys_for_logging.stderr = _LoggerWriter(logger.error)
+sys.stdout = _sys_for_logging.stdout
+sys.stderr = _sys_for_logging.stderr
+
 # Hugging Face token (optional) - prefer setting this in your environment
 HF_TOKEN = os.environ.get('HF_TOKEN')  # Set HF_TOKEN environment variable
 

31 Indobert-base-p1_without_law_with_svr.py

@@ -18,6 +18,7 @@ from pathlib import Path
 from tqdm.auto import tqdm
 import matplotlib.pyplot as plt
 import seaborn as sns
+import logging
 
 import torch
 from datasets import Dataset, DatasetDict
@@ -63,6 +64,73 @@ if not HF_TOKEN:
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print(f"Device detected: {device}")
 
+# ------------------------------------------------------------------
+# Logging setup: write console output and prints to a file in OUTPUT_DIR
+# This captures print() output by redirecting sys.stdout/stderr to the logger
+# ------------------------------------------------------------------
+import sys as _sys_for_logging
+
+# Ensure output dir exists so log file can be created early
+Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+log_file = Path(OUTPUT_DIR) / "run.log"
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s")
+
+# File handler (append)
+fh = logging.FileHandler(log_file, encoding='utf-8')
+fh.setLevel(logging.INFO)
+fh.setFormatter(formatter)
+logger.addHandler(fh)
+
+# Stream handler to keep console output (stdout)
+sh = logging.StreamHandler(_sys_for_logging.stdout)
+sh.setLevel(logging.INFO)
+sh.setFormatter(formatter)
+logger.addHandler(sh)
+
+class _LoggerWriter:
+    def __init__(self, level_func):
+        self.level_func = level_func
+
+    def write(self, message):
+        if message is None:
+            return
+        if isinstance(message, (bytes, bytearray)):
+            try:
+                message = message.decode('utf-8', errors='replace')
+            except Exception:
+                message = str(message)
+        if message and message.strip() != "":
+            self.level_func(message.rstrip("\n"))
+
+    def flush(self):
+        return
+
+    def isatty(self):
+        return False
+
+    @property
+    def encoding(self):
+        return getattr(_sys_for_logging.__stdout__, 'encoding', 'utf-8')
+
+    def fileno(self):
+        try:
+            return _sys_for_logging.__stdout__.fileno()
+        except Exception:
+            raise OSError("fileno() is not supported by _LoggerWriter")
+
+    def writable(self):
+        return True
+
+_sys_for_logging.stdout = _sys_for_logging.__stdout__
+_sys_for_logging.stderr = _sys_for_logging.__stderr__
+_sys_for_logging.stdout = _LoggerWriter(logger.info)
+_sys_for_logging.stderr = _LoggerWriter(logger.error)
+sys.stdout = _sys_for_logging.stdout
+sys.stderr = _sys_for_logging.stderr
+
 
 # ======================================================
 # 1. Dataset Download & Prep

32 Indobert-base-p1_with_law_with_svr.py

@@ -18,6 +18,7 @@ from pathlib import Path
 from tqdm.auto import tqdm
 import matplotlib.pyplot as plt
 import seaborn as sns
+import logging
 
 import torch
 from datasets import Dataset, DatasetDict
@@ -63,6 +64,73 @@ if not HF_TOKEN:
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print(f"Device detected: {device}")
 
+# ------------------------------------------------------------------
+# Logging setup: write console output and prints to a file in OUTPUT_DIR
+# This captures print() output by redirecting sys.stdout/stderr to the logger
+# ------------------------------------------------------------------
+import sys as _sys_for_logging
+
+# Ensure output dir exists so log file can be created early
+Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+log_file = Path(OUTPUT_DIR) / "run.log"
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s")
+
+# File handler (append)
+fh = logging.FileHandler(log_file, encoding='utf-8')
+fh.setLevel(logging.INFO)
+fh.setFormatter(formatter)
+logger.addHandler(fh)
+
+# Stream handler to keep console output (stdout)
+sh = logging.StreamHandler(_sys_for_logging.stdout)
+sh.setLevel(logging.INFO)
+sh.setFormatter(formatter)
+logger.addHandler(sh)
+
+class _LoggerWriter:
+    def __init__(self, level_func):
+        self.level_func = level_func
+
+    def write(self, message):
+        if message is None:
+            return
+        if isinstance(message, (bytes, bytearray)):
+            try:
+                message = message.decode('utf-8', errors='replace')
+            except Exception:
+                message = str(message)
+        if message and message.strip() != "":
+            self.level_func(message.rstrip("\n"))
+
+    def flush(self):
+        return
+
+    def isatty(self):
+        return False
+
+    @property
+    def encoding(self):
+        return getattr(_sys_for_logging.__stdout__, 'encoding', 'utf-8')
+
+    def fileno(self):
+        try:
+            return _sys_for_logging.__stdout__.fileno()
+        except Exception:
+            raise OSError("fileno() is not supported by _LoggerWriter")
+
+    def writable(self):
+        return True
+
+_sys_for_logging.stdout = _sys_for_logging.__stdout__
+_sys_for_logging.stderr = _sys_for_logging.__stderr__
+_sys_for_logging.stdout = _LoggerWriter(logger.info)
+_sys_for_logging.stderr = _LoggerWriter(logger.error)
+sys.stdout = _sys_for_logging.stdout
+sys.stderr = _sys_for_logging.stderr
+
 
 # ======================================================
 # 1. Dataset Download & Prep

41 Indobert-base-p1_without_law_mlp.py

@@ -114,6 +114,70 @@ def set_seed(seed: int):
 # Apply seed early so operations below are deterministic where possible
 set_seed(SEED)
 
+import logging
+
+import sys as _sys_for_logging
+
+# Ensure output dir exists so log file can be created early
+Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+log_file = Path(OUTPUT_DIR) / "run.log"
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s")
+
+# File handler (append)
+fh = logging.FileHandler(log_file, encoding='utf-8')
+fh.setLevel(logging.INFO)
+fh.setFormatter(formatter)
+logger.addHandler(fh)
+
+# Stream handler to keep console output (stdout)
+sh = logging.StreamHandler(_sys_for_logging.stdout)
+sh.setLevel(logging.INFO)
+sh.setFormatter(formatter)
+logger.addHandler(sh)
+
+class _LoggerWriter:
+    def __init__(self, level_func):
+        self.level_func = level_func
+
+    def write(self, message):
+        if message is None:
+            return
+        if isinstance(message, (bytes, bytearray)):
+            try:
+                message = message.decode('utf-8', errors='replace')
+            except Exception:
+                message = str(message)
+        if message and message.strip() != "":
+            self.level_func(message.rstrip("\n"))
+
+    def flush(self):
+        return
+
+    def isatty(self):
+        return False
+
+    @property
+    def encoding(self):
+        return getattr(_sys_for_logging.__stdout__, 'encoding', 'utf-8')
+
+    def fileno(self):
+        try:
+            return _sys_for_logging.__stdout__.fileno()
+        except Exception:
+            raise OSError("fileno() is not supported by _LoggerWriter")
+
+    def writable(self):
+        return True
+
+_sys_for_logging.stdout = _sys_for_logging.__stdout__
+_sys_for_logging.stderr = _sys_for_logging.__stderr__
+_sys_for_logging.stdout = _LoggerWriter(logger.info)
+_sys_for_logging.stderr = _LoggerWriter(logger.error)
+sys.stdout = _sys_for_logging.stdout
+sys.stderr = _sys_for_logging.stderr
 # Hugging Face token (optional) - prefer setting this in your environment
 HF_TOKEN = os.environ.get('HF_TOKEN')  # Set HF_TOKEN environment variable
 

42 Indobert-base-p1_with_law_mlp.py

@@ -132,6 +132,74 @@ WANDB_PROJECT = os.environ.get('WANDB_PROJECT') or 'Skripsi-Regression'
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print(f"Device detected: {device}")
 
+# ------------------------------------------------------------------
+# Logging setup: write console output and prints to a file in OUTPUT_DIR
+# This captures print() output by redirecting sys.stdout/stderr to the logger
+# ------------------------------------------------------------------
+import logging
+import sys as _sys_for_logging
+
+# Ensure output dir exists so log file can be created early
+Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+log_file = Path(OUTPUT_DIR) / "run.log"
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s")
+
+# File handler (append)
+fh = logging.FileHandler(log_file, encoding='utf-8')
+fh.setLevel(logging.INFO)
+fh.setFormatter(formatter)
+logger.addHandler(fh)
+
+# Stream handler to keep console output (stdout)
+sh = logging.StreamHandler(_sys_for_logging.stdout)
+sh.setLevel(logging.INFO)
+sh.setFormatter(formatter)
+logger.addHandler(sh)
+
+class _LoggerWriter:
+    def __init__(self, level_func):
+        self.level_func = level_func
+
+    def write(self, message):
+        if message is None:
+            return
+        if isinstance(message, (bytes, bytearray)):
+            try:
+                message = message.decode('utf-8', errors='replace')
+            except Exception:
+                message = str(message)
+        if message and message.strip() != "":
+            self.level_func(message.rstrip("\n"))
+
+    def flush(self):
+        return
+
+    def isatty(self):
+        return False
+
+    @property
+    def encoding(self):
+        return getattr(_sys_for_logging.__stdout__, 'encoding', 'utf-8')
+
+    def fileno(self):
+        try:
+            return _sys_for_logging.__stdout__.fileno()
+        except Exception:
+            raise OSError("fileno() is not supported by _LoggerWriter")
+
+    def writable(self):
+        return True
+
+_sys_for_logging.stdout = _sys_for_logging.__stdout__
+_sys_for_logging.stderr = _sys_for_logging.__stderr__
+_sys_for_logging.stdout = _LoggerWriter(logger.info)
+_sys_for_logging.stderr = _LoggerWriter(logger.error)
+sys.stdout = _sys_for_logging.stdout
+sys.stderr = _sys_for_logging.stderr
+
 # Quick IndoBERT load test (non-fatal). This will try with HF_TOKEN if provided.
 try:
     tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, token=HF_TOKEN)