FeatureRank 0.1.2__tar.gz → 0.1.4__tar.gz

{featurerank-0.1.2 → featurerank-0.1.4}/FeatureRank/GUI.py

@@ -19,6 +19,7 @@ from tkinter import filedialog, messagebox, ttk
 
 PERCENT_VALUES = tuple(str(value) for value in range(10, 101, 10))
 BLOCK_VALUES = ("5", "10", "20")
+NO_DATASET_LABEL = "No Dataset"
 MODE_LABELS = {
     "GL": "GL — Global Feature Ranking",
     "DC": "DC — Divide & Combine Feature Ranking",
@@ -40,9 +41,42 @@ def _dataset_choices() -> list[str]:
         if not directory.exists():
             continue
         for data_file in sorted(directory.glob("*_data.csv")):
-            if data_file.is_file() and data_file.name not in choices:
-                choices.append(data_file.name)
-    return choices or ["breast_cancer_data.csv"]
+            absolute_path = str(data_file.resolve())
+            if data_file.is_file() and absolute_path not in choices:
+                choices.append(absolute_path)
+    return choices or [NO_DATASET_LABEL]
+
+
+def _resolve_dataset_path(dataset: str) -> str:
+    """Use an absolute path when the selected file exists locally."""
+    requested = Path(dataset).expanduser()
+    if requested.is_file():
+        return str(requested.resolve())
+
+    project_root = Path(__file__).resolve().parent.parent
+    candidates = (
+        Path.cwd() / requested,
+        Path.cwd() / "data" / "raw" / requested,
+        project_root / requested,
+        project_root / "data" / "raw" / requested,
+    )
+    for candidate in candidates:
+        if candidate.is_file():
+            return str(candidate.resolve())
+    return dataset
+
+
+def _worker_python() -> Path:
+    """Find a project virtual-environment interpreter before the system one."""
+    project_root = Path(__file__).resolve().parent.parent
+    executable_name = "python.exe" if os.name == "nt" else "python"
+    candidates = (
+        Path.cwd() / ".venv" / ("Scripts" if os.name == "nt" else "bin") / executable_name,
+        project_root / ".venv" / ("Scripts" if os.name == "nt" else "bin") / executable_name,
+        Path(sys.executable).with_name("python"),
+        Path(sys.executable),
+    )
+    return next((candidate for candidate in candidates if candidate.is_file()), candidates[-1])
 
 
 def _open_folder(path: Path) -> None:
@@ -79,16 +113,27 @@ class FeatureRankGUI:
     def __init__(self, root: tk.Tk) -> None:
         self.root = root
         self.root.title("FeatureRank")
-        self.root.geometry("780x720")
-        self.root.minsize(700, 620)
+        # Keep the first view compact; the log can still grow when resized.
+        self.root.geometry("760x680")
+        self.root.minsize(680, 600)
 
         self.messages: queue.Queue[tuple[str, object]] = queue.Queue()
         self.worker: threading.Thread | None = None
         self.last_output_dir: Path | None = None
         self.block_count = 10
         self.blocks_seen = 0
+        self.progress_value = 0.0
+        self.progress_started_at: float | None = None
+        self.progress_job: str | None = None
+        self.progress_running = False
+
+        dataset_paths = _dataset_choices()
+        self.dataset_paths = {
+            Path(path).name: path for path in dataset_paths if path != NO_DATASET_LABEL
+        }
+        self.dataset_labels = [NO_DATASET_LABEL, *self.dataset_paths]
 
-        self.dataset_var = tk.StringVar(value=_dataset_choices()[0])
+        self.dataset_var = tk.StringVar(value=NO_DATASET_LABEL)
         self.percent_var = tk.StringVar(value="20")
         self.task_var = tk.StringVar(value="Classification")
         self.mode_var = tk.StringVar(value=MODE_LABELS["GL"])
@@ -121,16 +166,56 @@ class FeatureRankGUI:
             style.theme_use("clam")
         except tk.TclError:
             pass
-        style.configure("Title.TLabel", font=("Helvetica", 20, "bold"), foreground="#1f2937")
-        style.configure("Subtitle.TLabel", font=("Helvetica", 10), foreground="#4b5563")
-        style.configure("Stage.TLabel", font=("Helvetica", 11, "bold"), foreground="#1f4e79")
-        style.configure("Run.TButton", font=("Helvetica", 11, "bold"), padding=(18, 8))
+        # A restrained palette gives the form a clean surface on all platforms.
+        self.root.configure(background="#f4f6f8")
+        style.configure("TFrame", background="#f4f6f8")
+        style.configure("TLabel", background="#ffffff", foreground="#1f2937")
+        style.configure("TLabelframe", background="#ffffff")
+        style.configure("TLabelframe.Label", background="#ffffff", foreground="#1f2937")
+        style.configure(
+            "Title.TLabel",
+            background="#f4f6f8",
+            font=("Helvetica", 20, "bold"),
+            foreground="#1f2937",
+        )
+        style.configure(
+            "Subtitle.TLabel",
+            background="#f4f6f8",
+            font=("Helvetica", 10),
+            foreground="#4b5563",
+        )
+        style.configure(
+            "Stage.TLabel",
+            background="#f4f6f8",
+            font=("Helvetica", 11, "bold"),
+            foreground="#1f4e79",
+        )
+        style.configure(
+            "Run.TButton",
+            background="#1f4e79",
+            foreground="#ffffff",
+            font=("Helvetica", 11, "bold"),
+            padding=(16, 6),
+        )
+        style.map(
+            "Run.TButton",
+            background=[("active", "#173a5c"), ("disabled", "#b9c3cf")],
+            foreground=[("disabled", "#eef2f6")],
+        )
+        style.configure(
+            "Horizontal.TProgressbar",
+            background="#1f4e79",
+            troughcolor="#e5e7eb",
+            bordercolor="#d1d5db",
+            lightcolor="#1f4e79",
+            darkcolor="#1f4e79",
+        )
 
     def _build_window(self) -> None:
         self.root.columnconfigure(0, weight=1)
         self.root.rowconfigure(3, weight=1)
 
-        header = ttk.Frame(self.root, padding=(28, 24, 28, 12))
+        header = ttk.Frame(self.root, padding=(24, 18, 24, 8))
         header.grid(row=0, column=0, sticky="ew")
         ttk.Label(header, text="FeatureRank", style="Title.TLabel").pack(anchor="w")
         ttk.Label(
@@ -139,53 +224,55 @@ class FeatureRankGUI:
             style="Subtitle.TLabel",
         ).pack(anchor="w", pady=(4, 0))
 
-        options = ttk.LabelFrame(self.root, text="Experiment", padding=18)
-        options.grid(row=1, column=0, padx=28, pady=8, sticky="ew")
+        options = ttk.LabelFrame(self.root, text="Experiment", padding=14)
+        options.grid(row=1, column=0, padx=24, pady=6, sticky="ew")
         options.columnconfigure(1, weight=1)
 
-        ttk.Label(options, text="Dataset").grid(row=0, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Dataset").grid(row=0, column=0, sticky="w", pady=5)
         self.dataset_combo = ttk.Combobox(
-            options, textvariable=self.dataset_var, values=_dataset_choices(), state="readonly"
+            options, textvariable=self.dataset_var, values=self.dataset_labels, state="readonly"
         )
-        self.dataset_combo.grid(row=0, column=1, sticky="ew", padx=(14, 8), pady=7)
+        self.dataset_combo.grid(row=0, column=1, sticky="ew", padx=(10, 6), pady=5)
         ttk.Button(options, text="Browse…", command=self._browse_dataset).grid(
-            row=0, column=2, pady=7
+            row=0, column=2, pady=5
         )
 
-        ttk.Label(options, text="Task").grid(row=1, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Task").grid(row=1, column=0, sticky="w", pady=5)
         ttk.Combobox(
             options,
             textvariable=self.task_var,
             values=tuple(TASK_LABELS),
             state="readonly",
-        ).grid(row=1, column=1, sticky="ew", padx=(14, 8), pady=7)
+        ).grid(row=1, column=1, sticky="ew", padx=(10, 6), pady=5)
 
-        ttk.Label(options, text="Feature Percent").grid(row=2, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Feature Percent").grid(row=2, column=0, sticky="w", pady=5)
         ttk.Combobox(
             options,
             textvariable=self.percent_var,
             values=PERCENT_VALUES,
             state="readonly",
             width=12,
-        ).grid(row=2, column=1, sticky="w", padx=(14, 8), pady=7)
+        ).grid(row=2, column=1, sticky="w", padx=(10, 6), pady=5)
 
-        ttk.Label(options, text="Mode").grid(row=3, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Mode").grid(row=3, column=0, sticky="w", pady=5)
         self.mode_combo = ttk.Combobox(
             options,
             textvariable=self.mode_var,
             values=tuple(MODE_LABELS.values()),
             state="readonly",
         )
-        self.mode_combo.grid(row=3, column=1, sticky="ew", padx=(14, 8), pady=7)
+        self.mode_combo.grid(row=3, column=1, sticky="ew", padx=(10, 6), pady=5)
         self.mode_combo.bind("<<ComboboxSelected>>", self._mode_changed)
 
-        ttk.Label(options, text="Block Count").grid(row=4, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Block Count").grid(row=4, column=0, sticky="w", pady=5)
         self.block_combo = ttk.Combobox(
             options, textvariable=self.block_var, values=BLOCK_VALUES, state="disabled", width=12
         )
-        self.block_combo.grid(row=4, column=1, sticky="w", padx=(14, 8), pady=7)
+        self.block_combo.grid(row=4, column=1, sticky="w", padx=(10, 6), pady=5)
 
-        action_row = ttk.Frame(self.root, padding=(28, 8, 28, 8))
+        # Keep the run controls in a shallow toolbar so START is not surrounded
+        # by a large empty band.
+        action_row = ttk.Frame(self.root, padding=(24, 2, 24, 2))
         action_row.grid(row=2, column=0, sticky="ew")
         action_row.columnconfigure(1, weight=1)
         self.start_button = ttk.Button(
@@ -196,14 +283,14 @@ class FeatureRankGUI:
             row=0, column=1, sticky="e", padx=(12, 0)
         )
 
-        progress_frame = ttk.Frame(self.root, padding=(28, 0, 28, 12))
+        progress_frame = ttk.Frame(self.root, padding=(24, 0, 24, 8))
         progress_frame.grid(row=3, column=0, sticky="nsew")
         progress_frame.columnconfigure(0, weight=1)
         progress_frame.rowconfigure(2, weight=1)
         self.progress = ttk.Progressbar(progress_frame, mode="determinate", maximum=100)
         self.progress.grid(row=0, column=0, sticky="ew")
         ttk.Label(progress_frame, textvariable=self.status_var, style="Subtitle.TLabel").grid(
-            row=1, column=0, sticky="w", pady=(6, 8)
+            row=1, column=0, sticky="w", pady=(5, 6)
         )
 
         log_frame = ttk.LabelFrame(progress_frame, text="Log / Output", padding=8)
@@ -212,7 +299,7 @@ class FeatureRankGUI:
         log_frame.rowconfigure(0, weight=1)
         self.log_text = tk.Text(
             log_frame,
-            height=13,
+            height=8,
             wrap="word",
             state="disabled",
             background="#f8fafc",
@@ -226,19 +313,19 @@ class FeatureRankGUI:
         scrollbar.grid(row=0, column=1, sticky="ns")
         self.log_text.configure(yscrollcommand=scrollbar.set)
 
-        summary = ttk.LabelFrame(self.root, text="Summary", padding=14)
-        summary.grid(row=4, column=0, padx=28, pady=(0, 10), sticky="ew")
+        summary = ttk.LabelFrame(self.root, text="Summary", padding=12)
+        summary.grid(row=4, column=0, padx=24, pady=(0, 8), sticky="ew")
         summary.columnconfigure(1, weight=1)
         for row, (key, value) in enumerate(self.summary_vars.items()):
             ttk.Label(summary, text=key).grid(row=row // 2, column=(row % 2) * 2, sticky="w")
             ttk.Label(summary, textvariable=value, foreground="#1f4e79").grid(
-                row=row // 2, column=(row % 2) * 2 + 1, sticky="w", padx=(8, 26), pady=2
+                row=row // 2, column=(row % 2) * 2 + 1, sticky="w", padx=(8, 22), pady=2
             )
 
         self.open_button = ttk.Button(
             self.root, text="Open Results Folder", command=self._open_results, state="disabled"
         )
-        self.open_button.grid(row=5, column=0, padx=28, pady=(0, 18), sticky="w")
+        self.open_button.grid(row=5, column=0, padx=24, pady=(0, 14), sticky="w")
 
     def _browse_dataset(self) -> None:
         selected = filedialog.askopenfilename(
@@ -246,14 +333,20 @@ class FeatureRankGUI:
             filetypes=[("CSV files", "*.csv"), ("Text files", "*.txt"), ("All files", "*.*")],
         )
         if selected:
-            self.dataset_var.set(selected)
+            # Keep the full path internally, but show only the file name in
+            # the form so the selected dataset remains readable.
+            self.dataset_paths[Path(selected).name] = selected
+            self.dataset_labels = [NO_DATASET_LABEL, *self.dataset_paths]
+            self.dataset_combo.configure(values=self.dataset_labels)
+            self.dataset_var.set(Path(selected).name)
 
     def _mode_changed(self, _event: object = None) -> None:
         is_dc = self.mode_var.get().startswith("DC")
         self.block_combo.configure(state="readonly" if is_dc else "disabled")
 
     def _start(self) -> None:
-        dataset = self.dataset_var.get().strip()
+        dataset_label = self.dataset_var.get().strip()
+        dataset = self.dataset_paths.get(dataset_label, "")
         if not dataset:
             messagebox.showerror("FeatureRank", "Please select a dataset.")
             return
@@ -273,10 +366,13 @@ class FeatureRankGUI:
         self.last_output_dir = None
         self.open_button.configure(state="disabled")
         self.start_button.configure(state="disabled")
-        self.progress.configure(value=2)
+        self.progress_value = 2.0
+        self.progress.configure(value=self.progress_value)
         self.stage_var.set("Loading Dataset")
         self.status_var.set("The experiment is running. You can follow progress in the log.")
         self._clear_log()
+        self.progress_started_at = time.perf_counter()
+        self.progress_running = True
 
         self.worker = threading.Thread(
             target=self._run_experiment,
@@ -284,12 +380,14 @@ class FeatureRankGUI:
             daemon=True,
         )
         self.worker.start()
+        self._animate_progress()
         self.root.after(100, self._poll_messages)
 
     def _run_experiment(
         self, dataset: str, percent: float, task: str, mode: str, block_count: int
     ) -> None:
         started_at = time.perf_counter()
+        output_lines: list[str] = []
         try:
             # Keep TensorFlow out of the Tk process.  On macOS, loading a model
             # from a GUI thread can terminate the native Python process.  The
@@ -297,8 +395,9 @@ class FeatureRankGUI:
             # stdout is streamed back into this window.
             from src.Config import ExperimentConfig
 
+            dataset_path = _resolve_dataset_path(dataset)
             config = ExperimentConfig(
-                dataset_name=dataset,
+                dataset_name=dataset_path,
                 task=task,
                 feature_percent=percent,
                 random_state=42,
@@ -308,15 +407,13 @@ class FeatureRankGUI:
                 cluster_k=None,
                 save_details=False,
             )
-            python_executable = Path(sys.executable).with_name("python")
-            if not python_executable.exists():
-                python_executable = Path(sys.executable)
+            python_executable = _worker_python()
             command = [
                 str(python_executable),
                 "-m",
                 "scripts.FeatureRank",
                 "--dataset-name",
-                dataset,
+                dataset_path,
                 "--task",
                 task,
                 "--feature-percent",
@@ -328,9 +425,18 @@ class FeatureRankGUI:
             if mode == "dc":
                 command.extend(["--block-count", str(block_count)])
 
+            worker_environment = os.environ.copy()
+            worker_environment["PYTHONUNBUFFERED"] = "1"
+            package_root = str(Path(__file__).resolve().parent.parent)
+            existing_python_path = worker_environment.get("PYTHONPATH")
+            worker_environment["PYTHONPATH"] = os.pathsep.join(
+                path for path in (package_root, existing_python_path) if path
+            )
+            self.messages.put(("log", f"Worker: {python_executable}"))
             process = subprocess.Popen(
                 command,
                 cwd=Path.cwd(),
+                env=worker_environment,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
                 text=True,
@@ -338,6 +444,7 @@ class FeatureRankGUI:
             )
             assert process.stdout is not None
             for line in process.stdout:
+                output_lines.append(line.rstrip())
                 self.messages.put(("log", line))
             return_code = process.wait()
             if return_code != 0:
@@ -347,7 +454,9 @@ class FeatureRankGUI:
                         "Anaconda TensorFlow paketini guncelleyin veya uyumlu bir "
                         "Python yorumlayicisi kullanin."
                     )
-                raise RuntimeError(f"FeatureRank worker stopped with code {return_code}.")
+                recent_output = "\n".join(line for line in output_lines[-12:] if line.strip())
+                details = f"\n\nSon worker çıktısı:\n{recent_output}" if recent_output else ""
+                raise RuntimeError(f"FeatureRank worker stopped with code {return_code}.{details}")
 
             average = 0.0
             values: list[float] = []
@@ -489,11 +598,31 @@ class FeatureRankGUI:
         elif "metrik" in lower or "metric" in lower or "tamamlandi" in lower:
             self._set_progress("Calculating Results", 95)
 
+    def _animate_progress(self) -> None:
+        """Advance the bar smoothly while the worker is still running.
+
+        Workflow messages move the bar to meaningful stages.  This timer fills
+        the gaps between those messages based on elapsed time, then waits near
+        90% until the worker reports completion instead of pretending to know
+        the exact duration of every dataset.
+        """
+        if not self.progress_running or self.progress_started_at is None:
+            return
+        elapsed = time.perf_counter() - self.progress_started_at
+        time_based_value = min(90.0, 2.0 + elapsed * 1.2)
+        if time_based_value > self.progress_value:
+            self.progress_value = time_based_value
+            self.progress.configure(value=self.progress_value)
+        self.status_var.set(f"The experiment is running. Elapsed time: {elapsed:.0f} s.")
+        self.progress_job = self.root.after(200, self._animate_progress)
+
     def _set_progress(self, stage: str, value: int) -> None:
         self.stage_var.set(stage)
-        self.progress.configure(value=min(value, 99))
+        self.progress_value = max(self.progress_value, float(min(value, 99)))
+        self.progress.configure(value=self.progress_value)
 
     def _completed(self, summary: dict[str, str]) -> None:
+        self._stop_progress_animation()
         for key, value in summary.items():
             self.summary_vars[key].set(value)
         output = summary.get("Output Directory", "N/A")
@@ -506,13 +635,22 @@ class FeatureRankGUI:
         self.start_button.configure(state="normal")
 
     def _failed(self, error: str) -> None:
+        self._stop_progress_animation()
         self.progress.configure(value=0)
+        self.progress_value = 0.0
         self.stage_var.set("Failed")
         self.status_var.set("The experiment could not be completed.")
         self._append_log(f"ERROR: {error}")
         self.start_button.configure(state="normal")
         messagebox.showerror("FeatureRank", error)
 
+    def _stop_progress_animation(self) -> None:
+        self.progress_running = False
+        self.progress_started_at = None
+        if self.progress_job is not None:
+            self.root.after_cancel(self.progress_job)
+            self.progress_job = None
+
     def _clear_log(self) -> None:
         self.log_text.configure(state="normal")
         self.log_text.delete("1.0", tk.END)

{featurerank-0.1.2 → featurerank-0.1.4}/FeatureRank/__init__.py

@@ -11,7 +11,7 @@ import sys
 
 from .GUI import Launch
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 
 def _run_cli(arguments: list[str] | None = None) -> None:

{featurerank-0.1.2 → featurerank-0.1.4/FeatureRank.egg-info}/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: FeatureRank
-Version: 0.1.2
+Version: 0.1.4
 Summary: Autoencoder-based feature ranking and selection workflows
 Author: Sercan
 License: MIT
-Requires-Python: >=3.13
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: numpy>=2.0
 Requires-Dist: pandas>=2.0
 Requires-Dist: numexpr>=2.10.2
 Requires-Dist: scikit-learn>=1.4
 Requires-Dist: matplotlib>=3.8
-Requires-Dist: tensorflow>=2.21
+Requires-Dist: tensorflow<2.22,>=2.21; platform_system != "Darwin" or platform_machine != "x86_64"
+Requires-Dist: tensorflow<2.17,>=2.16.2; platform_system == "Darwin" and platform_machine == "x86_64" and python_version < "3.13"
 
 # FeatureRank
 
@@ -28,23 +29,45 @@ The project supports two selection modes:
 The selected features can be evaluated with classification, regression, or
 unsupervised clustering.
 
-## Installation
+## PyPI installation and GUI (end users)
 
-Use Python 3.13. For the published package, install the latest release with:
+FeatureRank supports 64-bit Python 3.10, 3.11, 3.12, and 3.13 on desktop
+Windows, Linux, and macOS systems. Python 3.14 is not supported yet. Intel
+macOS users should use Python 3.12 or earlier because newer TensorFlow releases
+do not provide an Intel macOS wheel. Check the Python version first:
 
 ```bash
-python -m pip install --upgrade FeatureRank
+python3 --version
 ```
 
-The package name is case-insensitive for `pip`, while the Python import name
-is `FeatureRank`. Verify the installation from Python (not directly in zsh):
+Install the published package with:
 
 ```bash
-python
+pip install FeatureRank
+```
+
+![Installing FeatureRank with pip](docs/images/01-pip-install.png)
+
+Open Python:
+
+```bash
+python3
+```
+
+![Opening Python 3](docs/images/02-python3.png)
+
+Then import FeatureRank at the Python prompt:
+
+```python
 >>> import FeatureRank
->>> print(FeatureRank.__file__)
 ```
 
+![Importing FeatureRank](docs/images/03-import-featurerank.png)
+
+The import opens the desktop GUI automatically. Do not type `import
+FeatureRank` directly in zsh; it is Python code and must be entered after
+starting `python3`.
+
 For local development, run these commands from the repository root instead:
 
 ```bash
@@ -58,10 +81,10 @@ GPU-specific dependencies are listed in
 [`requirements-gpu.txt`](requirements-gpu.txt). Hardware notes are available in
 [`GPU_SETUP.md`](GPU_SETUP.md).
 
-The repository metadata is version `0.1.2`. Because PyPI releases cannot be
+The repository metadata is version `0.1.4`. Because PyPI releases cannot be
 replaced in place, publish this version (or a newer one) to the existing
 `FeatureRank` project when you release the refactor. If an environment still
-shows `FeatureRank==0.1.0`, upgrade it with the command above or use the local
+shows an older FeatureRank version, upgrade it with the command above or use the local
 editable installation while developing.
 
 After installation, the package GUI can be opened with:
@@ -96,12 +119,17 @@ in that interpreter's environment.
 If you do not want to install the package, use the equivalent script directly:
 
 ```bash
-python scripts/FeatureRank.py --help
+python3 scripts/FeatureRank.py --help
 ```
 
-## Using FeatureRank
+## Optional Python API (developers)
+
+The main entry point for regular users is the GUI shown above. The following
+Python API is optional and is useful when another Python program needs to start
+an experiment. It is not required for the normal `pip install` → `import
+FeatureRank` workflow.
 
-The main entry point is:
+The main command-line entry point is:
 
 ```text
 scripts/FeatureRank.py
@@ -136,28 +164,45 @@ The GUI is the primary end-user interface. Select a dataset from the dropdown
 or choose a CSV/TXT file with **Browse…**, select a feature percentage, choose
 `GL` or `DC`, and press **START**. `Block Count` is enabled only for `DC`.
 
+When the GUI opens, the experiment form is ready for these choices:
+
+![FeatureRank GUI](docs/images/04-gui-ready.png)
+
+If the required dataset is not listed, press **Browse…** and select its data
+file. For paired datasets, keep the matching label file in the same directory:
+
+![Selecting a dataset](docs/images/05-browse-dataset.png)
+
 While the model runs, the progress bar and log show stages such as loading,
 feature ranking, block processing, combining, training, and result creation.
 When the run finishes, the summary lists the selected feature count, metric,
 execution time, and output directory. **Open Results Folder** opens that
 directory in Finder, Explorer, or the Linux file manager.
 
+![Completed FeatureRank result](docs/images/06-results.png)
+
 The selected file can be a normal CSV containing a `target` column, or one of
 the project's paired files (`*_data.csv` and `*_label.csv`).
 
-## Using from Terminal
+## Local repository command-line mode (developers)
+
+The GUI is the normal user interface. The commands in this section are optional
+and are intended for developers, batch experiments, and reproducible research.
+They bypass the GUI and run the existing workflow directly in the terminal.
+They are available from a repository checkout; a normal PyPI user does not need
+them.
 
-The original parameterized CLI remains available for development and backward
-compatibility. To inspect its options:
+Run these shell commands directly in Terminal. Do not first open the Python
+prompt and do not type the `>>>` marker. To inspect the CLI options:
 
 ```bash
-python scripts/FeatureRank.py --help
+python3 scripts/FeatureRank.py --help
 ```
 
 A normal classification run is:
 
 ```bash
-python scripts/FeatureRank.py \
+python3 scripts/FeatureRank.py \
   --dataset-name breast_cancer_data.csv \
   --task classification \
   --feature-percent 20 \
@@ -167,7 +212,7 @@ python scripts/FeatureRank.py \
 The command can also be run through the compatibility wrapper:
 
 ```bash
-python scripts/RunAutoencoder.py \
+python3 scripts/RunAutoencoder.py \
   --dataset-name breast_cancer_data.csv \
   --feature-percent 20
 ```
@@ -189,7 +234,7 @@ workflow is:
 Run GLOBAL explicitly with:
 
 ```bash
-python scripts/FeatureRank.py \
+python3 scripts/FeatureRank.py \
   --dataset-name carcinom_data.csv \
   --task classification \
   --feature-percent 40 \
@@ -218,7 +263,7 @@ The steps are:
 Run DC with ten blocks:
 
 ```bash
-python scripts/FeatureRank.py \
+python3 scripts/FeatureRank.py \
   --dataset-name arcene_data.csv \
   --task classification \
   --feature-percent 50 \
@@ -284,19 +329,19 @@ Examples:
 
 ```bash
 # Classification
-python scripts/FeatureRank.py \
+python3 scripts/FeatureRank.py \
   --dataset-name breast_cancer_data.csv \
   --task classification \
   --feature-percent 20
 
 # Regression
-python scripts/FeatureRank.py \
+python3 scripts/FeatureRank.py \
   --dataset-name air_data.csv \
   --task regression \
   --feature-percent 30
 
 # Clustering
-python scripts/FeatureRank.py \
+python3 scripts/FeatureRank.py \
   --dataset-name codon_usage_data.csv \
   --task clustering \
   --feature-percent 60
@@ -322,7 +367,7 @@ The main user-facing parameters are:
 For the complete, current list:
 
 ```bash
-python scripts/FeatureRank.py --help
+python3 scripts/FeatureRank.py --help
 ```
 
 Model architecture, epochs, batch size, learning rate, early stopping, and
@@ -423,9 +468,9 @@ in [`requirements-gpu.txt`](requirements-gpu.txt).
 Run the checks from the repository root:
 
 ```bash
-python -m pytest -q
-python -m pyflakes src scripts tests
-python -m compileall -q src scripts tests
+python3 -m pytest -q
+python3 -m pyflakes src scripts tests
+python3 -m compileall -q src scripts tests
 ```
 
 ## Citation