sampling-mining-workflows-dsl 0.0.1__py3-none-any.whl

sampling_mining_workflows_dsl/analysis/HistAnalysis.py

@@ -0,0 +1,201 @@
+import os
+from collections import Counter
+from typing import TYPE_CHECKING
+
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+import pandas as pd
+
+from sampling_mining_workflows_dsl.element.Set import Set
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.metadata import MetadataValue
+
+
+class HistAnalysis:
+    def __init__(
+        self,
+        save_path: str,
+        metadata: Metadata,
+        top_x: int = -1,
+        category: bool = True,
+        sort: bool = False,
+        show: bool = False,
+        log_y: bool = False,
+        fixed_bins: int = None,
+        max_x_bound: float = None,
+        x_label: str = None,
+        fig_size=(10,6),
+    ):
+        self.metadata = metadata
+        # Wether data should be treated as categorical data or continous
+        self.category = category
+        self.top_x = top_x
+        self.sort = sort
+        self.save_path = save_path
+        os.makedirs(self.save_path, exist_ok=True)
+        self.show = show
+        self.log_y = log_y
+        self.fixed_bins = fixed_bins
+        self.max_x_bound = max_x_bound
+        self.x_label = x_label
+        self.fig_size = fig_size
+
+    def analyze(self, s: Set, file_name: str, op_info: str):
+        # From Set to List of Metadata values
+        try:
+            metadata_values = []
+            for element in s.get_elements():
+                if not isinstance(element, Set):
+                    metadata_value: MetadataValue = element.get_metadata_value(
+                        self.metadata
+                    )
+                    if self.metadata.type is list:
+                        metadata_values.extend(metadata_value.get_value())
+                    else:
+                        metadata_values.append(metadata_value.get_value())
+
+            if self.top_x > 0:
+                # Count all and find top_x
+                counter = Counter(metadata_values)
+                most_common = dict(counter.most_common(self.top_x))
+                top_values = set(most_common.keys())
+
+                # Replace non-top values with 'Other'
+                metadata_values = [
+                    val if val in top_values else "Other" for val in metadata_values
+                ]
+
+            fig, ax = self.create_histogram(metadata_values, op_info)
+            if self.show:    
+                self.show_histogram()
+            self.save_histogram(fig, file_name)
+        except Exception as e:
+            print(f"Error analyzing {self.metadata.name}: {e}")
+            return
+
+    def create_histogram(self, data: list, op_info: str):
+        df = pd.DataFrame(data, columns=["value"])
+        series = df["value"]
+
+        # Apply max x bound filter if specified
+        if self.max_x_bound is not None and not self.category:
+            # Only filter for continuous data
+            filtered_data = [x for x in data if x <= self.max_x_bound]
+            df = pd.DataFrame(filtered_data, columns=["value"])
+            series = df["value"]
+            data = filtered_data
+
+
+        # Set style and create figure with better styling
+        plt.style.use('default')  # Reset to default style
+        fig, ax = plt.subplots(figsize=self.fig_size)
+        fig.patch.set_facecolor('white')
+        
+        if not self.category:
+            unique_values = series.nunique()
+            # Determine number of bins
+            if self.fixed_bins is not None:
+                bins = self.fixed_bins
+            else:
+                bins = min(10, unique_values)
+            
+            # Create histogram with better styling
+            n, bins_edges, patches = ax.hist(
+                x=data, 
+                bins=bins,
+                color="#000000",  # Dark blue color
+                alpha=0.85,
+                edgecolor="#C9CCD3",  # Very dark blue border
+                linewidth=1.2
+            )
+            
+            if self.log_y:
+                ax.set_yscale('log')
+            
+            # Set x-axis limit if max_x_bound is specified
+            if self.max_x_bound is not None:
+                ax.set_xlim(right=self.max_x_bound)
+        else:
+            if self.sort:
+                value_counts = series.value_counts(ascending=False, sort=True)
+            else:
+                value_counts = series.value_counts().sort_index(ascending=True)
+            
+            # Create bar chart with better styling
+            value_counts.plot(
+                kind="bar", 
+                ax=ax,
+                color="#000000",  # Dark blue color
+                alpha=0.85,
+                edgecolor='#C9CCD3',  # Very dark blue border
+                linewidth=1.2
+            )
+            
+            
+            # Set custom x-label or default
+            x_axis_label = self.x_label if self.x_label else "Category"
+            ax.set_xlabel(x_axis_label, fontsize=16, fontweight='bold')
+            
+            # Rotate x-axis labels for better readability
+            plt.xticks(rotation=45, ha='right', fontsize=14)
+
+        # Enhanced styling
+        ax.set_title(op_info, fontsize=18, fontweight='bold', pad=20)
+        
+        # Y-axis label with log scale indication
+        y_label = "Frequency"
+        if self.log_y:
+            y_label += " (Log Scale)"
+        ax.set_ylabel(y_label, fontsize=16, fontweight='bold')
+        
+        # Set custom x-label for continuous data if provided
+        if not self.category and self.x_label:
+            ax.set_xlabel(self.x_label, fontsize=16, fontweight='bold')
+        
+        # Grid styling
+        ax.grid(True, alpha=0.3, linestyle='-', linewidth=0.5)
+        ax.set_axisbelow(True)
+        
+        # Spine styling
+        for spine in ax.spines.values():
+            spine.set_color('#333333')
+            spine.set_linewidth(1)
+        
+        # Make axes more visible with intermediate ticks
+        ax.tick_params(axis='both', which='major', labelsize=14, colors='#333333')
+        ax.tick_params(axis='both', which='minor', labelsize=12, colors='#666666')
+        
+        # Add minor ticks for Y axis for better readability
+        ax.yaxis.set_minor_locator(ticker.AutoMinorLocator())
+        
+        # If log scale, use log minor locator for Y axis
+        if self.log_y:
+            ax.yaxis.set_minor_locator(ticker.LogLocator(base=10.0, subs='auto', numticks=4))
+        
+        # Format axis numbers with separators
+        # Format x-axis with space separators for thousands
+        if not self.category:
+
+            ax.xaxis.set_major_formatter(ticker.FuncFormatter(lambda x, p: f"{x:,.0f}"))
+            # Format y-axis with space separators for thousands
+            ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, p: f"{x:,.0f}"))
+        
+        plt.tight_layout()
+        return fig, ax
+
+    def save_histogram(self, fig, file_name: str):
+        
+        if file_name:
+            # Create folder if needed
+            os.makedirs(self.save_path, exist_ok=True)
+            file_path = os.path.join(self.save_path, file_name)
+            fig.savefig(file_path)
+        else:
+            print("No save path provided, displaying histogram instead.")
+            self.show_histogram()
+        plt.close(fig)
+
+    def show_histogram(self):
+        plt.show()

sampling_mining_workflows_dsl/analysis/HistWorkflowAnalysis.py

@@ -0,0 +1,72 @@
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.analysis.HistAnalysis import HistAnalysis
+from sampling_mining_workflows_dsl.analysis.WorkflowAnalysis import WorkflowAnalysis
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+from sampling_mining_workflows_dsl.operator.clustering.GroupingOperator import GroupingOperator
+
+T = TypeVar("T")
+
+
+class HistWorkflowAnalysis(WorkflowAnalysis):
+    def __init__(
+        self,
+        metadata: Metadata[T],
+        top_x: int = -1,
+        category: bool = True,
+        sort: bool = False,
+        output_path: str = "hist_analysis/",
+        log_y: bool = False,
+        fixed_bins: int = None,
+        max_x_bound: float = None,
+        x_label: str = None,
+        fig_size=(10,6)
+    ):
+        super().__init__()
+        self.category = category
+        self.sort = sort
+        self.metadata = metadata
+        self.file_path = output_path
+        self.top_x = top_x
+        self.log_y = log_y
+        self.fixed_bins = fixed_bins
+        self.max_x_bound = max_x_bound
+        self.x_label = x_label
+        self.fig_size = fig_size
+
+    def analyze(
+        self, workflow, workflow_name: str = "main workflow", op_number: int = 1
+    ):
+        op = workflow.get_root()
+        analysis = HistAnalysis(
+            self.file_path, self.metadata, self.top_x, self.category, self.sort, 
+            show=False, log_y=self.log_y, fixed_bins=self.fixed_bins, 
+            max_x_bound=self.max_x_bound, x_label=self.x_label,fig_size=self.fig_size
+        )
+        analysis.analyze(
+            op.get_input(),
+            f"{self.metadata.name}_{workflow_name}_op{op_number}_input.svg",
+            f"",
+        )
+
+        while op is not None:
+            if isinstance(op, GroupingOperator):
+                analysis.analyze(
+                    op.get_merged_output(),
+                    f"{self.metadata.name}_{workflow_name}_op{op_number}_output.svg",
+                    f"",
+                )
+                for i, internal_w in enumerate(op.get_workflows(), start=1):
+                    # Recursively analyze subworkflows
+                    subworkflow_name = f"subworkflow {i}"
+                    self.analyze(
+                        internal_w, subworkflow_name, 1
+                    )  # Reset operator numbering for subworkflows
+            else:
+                analysis.analyze(
+                    op.get_output(),
+                    f"{self.metadata.name}_{workflow_name}_op{op_number}_output.svg",
+                    f"",
+                )
+            op = op.get_next_operator()
+            op_number += 1

sampling_mining_workflows_dsl/analysis/KSWorkflowAnalysis.py

@@ -0,0 +1,217 @@
+from typing import TypeVar
+
+
+from sampling_mining_workflows_dsl.Workflow import Workflow
+from sampling_mining_workflows_dsl.analysis.HistAnalysis import HistAnalysis
+from sampling_mining_workflows_dsl.analysis.WorkflowAnalysis import WorkflowAnalysis
+from sampling_mining_workflows_dsl.analysis.kolmogorov_smirnov import kolmogorov_smirnov
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+from sampling_mining_workflows_dsl.operator.clustering.GroupingOperator import (
+    GroupingOperator,
+)
+
+T = TypeVar("T")
+
+
+class KSWorkflowAnalysis(WorkflowAnalysis):
+    def __init__(
+        self,
+        metadata: Metadata[T],
+        output_path: str = "analysis",
+    ):
+        super().__init__()
+
+        self.metadata = metadata
+        self.file_path = output_path+"/ks_analysis.txt"
+
+    def analyze(
+        self, workflow
+    ):
+        import os
+        from datetime import datetime
+        
+        # Create all directory if it doesn't exist
+        os.makedirs(os.path.dirname(self.file_path), exist_ok=True)        
+        print(f"KS Analysis results will be saved in {self.file_path}")
+        
+        # Store pairs that pass the test
+        passing_pairs = []
+        failing_pairs = []
+        
+        # Open file for writing
+        with open(self.file_path, 'w', encoding='utf-8') as f:
+            # Write header
+            f.write(f"Kolmogorov-Smirnov Analysis Results\n")
+            f.write(f"{'='*50}\n")
+            f.write(f"Metadata: {self.metadata.name}\n")
+            f.write(f"{'='*50}\n\n")
+
+            #compute for all pair
+            tuples = self.get_all_set_from_workflow(workflow)
+            
+            if len(tuples) < 2:
+                f.write("Warning: Less than 2 sets found. Cannot perform pairwise analysis.\n")
+                print("Warning: Less than 2 sets found. Cannot perform pairwise analysis.")
+                return
+            
+            comparison_count = 0
+            for i in range(0, len(tuples)):
+                for j in range(i, len(tuples)):
+                    set_1, op_1 = tuples[i]
+                    set_2, op_2 = tuples[j]
+                    
+                    comparison_count += 1
+                    
+                    # Write comparison header
+                    op_1_name = op_1.__class__.__name__ if op_1 else 'Initial set'
+                    op_1_name = f"Set #{i}"+op_1_name
+                    op_2_name = op_2.__class__.__name__ if op_2 else 'Initial Input'
+                    op_2_name = f"Set #{j}"+op_2_name
+                    f.write(f"Comparison #{comparison_count}\n")
+                    f.write(f"Set 1: {op_1_name} (size: {set_1.size()})\n")
+                    f.write(f"Set 2: {op_2_name} (size: {set_2.size()})\n")
+                    f.write(f"{'-'*30}\n")
+                    
+                    # Perform KS analysis
+                    print(f"Analyzing sets {i} from {op_1_name} and {j} from {op_2_name}")
+                    
+                    try:
+                        ks_result = kolmogorov_smirnov(self.metadata).analyze(set_1, set_2)
+                        
+                        # Extract results from KstestResult object
+                        statistic = ks_result.statistic if hasattr(ks_result, 'statistic') else 'N/A'
+                        p_value = ks_result.pvalue if hasattr(ks_result, 'pvalue') else 'N/A'
+                        
+                        # Create interpretation
+                        if p_value != 'N/A':
+                            if p_value > 0.05:
+                                interpretation = "No significant difference (p > 0.05)"
+                            else:
+                                interpretation = "Significant difference detected (p ≤ 0.05)"
+                        else:
+                            interpretation = "Unable to determine"
+                        
+                        # Check if test passes (typically p_value > 0.05 means no significant difference)
+                        test_passed = p_value != 'N/A' and float(p_value) > 0.05
+                        
+                        pair_info = {
+                            'comparison': comparison_count,
+                            'set_1': op_1_name,
+                            'set_2': op_2_name,
+                            'statistic': statistic,
+                            'p_value': p_value,
+                            'interpretation': interpretation
+                        }
+                        
+                        if test_passed:
+                            passing_pairs.append(pair_info)
+                            f.write(f"✓ TEST PASSED - ")
+                        else:
+                            failing_pairs.append(pair_info)
+                            f.write(f"✗ TEST FAILED - ")
+                        
+                        # Write results to file
+                        f.write(f"KS Statistic: {statistic}\n")
+                        f.write(f"P-value: {p_value}\n")
+                        f.write(f"Interpretation: {interpretation}\n")
+                        
+                        # Print to console as well
+                        status = "PASSED" if test_passed else "FAILED"
+                        print(f"  [{status}] KS Statistic: {statistic}, P-value: {p_value}")
+                        
+                    except Exception as e:
+                        error_msg = f"Error during analysis: {str(e)}"
+                        f.write(f"{error_msg}\n")
+                        print(f"  {error_msg}")
+                        failing_pairs.append({
+                            'comparison': comparison_count,
+                            'set_1': op_1_name,
+                            'set_2': op_2_name,
+                            'error': str(e)
+                        })
+                    
+                    f.write(f"\n")
+            
+            # Write summary section
+            f.write(f"\n{'='*50}\n")
+            f.write(f"SUMMARY\n")
+            f.write(f"{'='*50}\n")
+            f.write(f"Total comparisons: {comparison_count}\n")
+            f.write(f"Tests passed: {len(passing_pairs)}\n")
+            f.write(f"Tests failed: {len(failing_pairs)}\n")
+            f.write(f"\nPassing pairs (no significant difference):\n")
+            f.write(f"{'-'*30}\n")
+            
+            if passing_pairs:
+                for pair in passing_pairs:
+                    f.write(f"• {pair['set_1']} vs {pair['set_2']} (p-value: {pair['p_value']})\n")
+            else:
+                f.write("None\n")
+            
+            f.write(f"\nFailing pairs (significant difference detected):\n")
+            f.write(f"{'-'*30}\n")
+            
+            if failing_pairs:
+                for pair in failing_pairs:
+                    if 'error' in pair:
+                        f.write(f"• {pair['set_1']} vs {pair['set_2']} (Error: {pair['error']})\n")
+                    else:
+                        f.write(f"• {pair['set_1']} vs {pair['set_2']} (p-value: {pair['p_value']})\n")
+            else:
+                f.write("None\n")
+            
+            f.write(f"\nAnalysis completed at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+        
+        # Print summary to console
+        print(f"\n{'='*50}")
+        print(f"KS ANALYSIS SUMMARY")
+        print(f"{'='*50}")
+        print(f"Total comparisons: {comparison_count}")
+        print(f"Tests passed: {len(passing_pairs)}")
+        print(f"Tests failed: {len(failing_pairs)}")
+        
+        if passing_pairs:
+            print(f"\nPassing pairs (no significant difference):")
+            for pair in passing_pairs:
+                print(f"  ✓ {pair['set_1']} vs {pair['set_2']} (p-value: {pair['p_value']})")
+        
+        if failing_pairs:
+            print(f"\nFailing pairs (significant difference detected):")
+            for pair in failing_pairs:
+                if 'error' in pair:
+                    print(f"  ✗ {pair['set_1']} vs {pair['set_2']} (Error)")
+                else:
+                    print(f"  ✗ {pair['set_1']} vs {pair['set_2']} (p-value: {pair['p_value']})")
+        
+        print(f"\nResults saved to: {self.file_path}")
+        
+        return {
+            'passing_pairs': passing_pairs,
+            'failing_pairs': failing_pairs,
+            'total_comparisons': comparison_count
+        }
+
+                
+
+
+    
+    def get_all_set_from_workflow(self, workflow: Workflow, index=0):
+        sets = {}
+        if index==0:
+            sets[index] = (workflow._input,None)
+            index += 1
+
+        op = workflow.get_root()
+        while op is not None:
+            if not isinstance(op, GroupingOperator):
+                if hasattr(op, "_output") and op._output is not None:
+                    sets[index] = (op._output,op)  
+                    index += 1
+            else:
+                for internal_w in op.get_workflows():
+                    grouping_sets = self.get_all_set_from_workflow(internal_w, index)
+                    index = index + len(grouping_sets)
+                    sets.update(grouping_sets)  
+            op = op.get_next_operator()
+
+        return sets

sampling_mining_workflows_dsl/analysis/WorkflowAnalysis.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class WorkflowAnalysis(ABC):
+    @abstractmethod
+    def analyze(self, workflow):
+        pass

sampling_mining_workflows_dsl/analysis/YamaneTest.py

@@ -0,0 +1,16 @@
+import math
+
+
+class YamaneTest:
+    def __init__(self, population_size: int, margin_of_error: float):
+        self.population_size = population_size
+        self.margin_of_error = margin_of_error
+
+    def calculate_required_sample_size(self) -> int:
+        return math.ceil(
+            self.population_size / (1 + self.population_size * self.margin_of_error**2)
+        )
+
+    def is_representative(self, given_sample_size: int) -> bool:
+        required_sample_size = self.calculate_required_sample_size()
+        return given_sample_size >= required_sample_size

sampling_mining_workflows_dsl/analysis/YamaneWorkflowAnalysis.py

@@ -0,0 +1,27 @@
+from sampling_mining_workflows_dsl.analysis.WorkflowAnalysis import WorkflowAnalysis
+from sampling_mining_workflows_dsl.analysis.YamaneTest import YamaneTest
+
+
+class YamaneWorkflowAnalysis(WorkflowAnalysis):
+    def __init__(self, margin_of_error: float = 0.05):
+        super().__init__()
+        self.margin_of_error = margin_of_error
+
+    def analyze(self, workflow):
+        pop_size = workflow.get_workflow_input().size()
+        yamane_test = YamaneTest(pop_size, self.margin_of_error)
+
+        required_sample_size = yamane_test.calculate_required_sample_size()
+        actual_sample_size = workflow.get_workflow_output().size()
+
+        print("Yamane's Test Analysis:")
+        print("Population Size (input size):", pop_size)
+        print("Required Sample Size:", required_sample_size)
+        print("Actual Sample Size:", actual_sample_size)
+
+        if yamane_test.is_representative(actual_sample_size):
+            print("The sample is representative based on Yamane's test.")
+        else:
+            print("The sample is not representative based on Yamane's test.")
+
+        print("------------------------------------------")

sampling_mining_workflows_dsl/analysis/kolmogorov_smirnov.py

@@ -0,0 +1,31 @@
+
+from scipy.stats import ks_2samp
+
+from sampling_mining_workflows_dsl.element.Repository import Repository
+from sampling_mining_workflows_dsl.element.Set import Set
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+
+class kolmogorov_smirnov:
+    def __init__(self, metadata: Metadata[int]):
+        self.metadata = metadata
+
+    def analyze(self, a: Set, sample: Set) -> float:
+        first_list = self.extract_list(a)
+        second_list = self.extract_list(sample)
+
+        # Perform the Kolmogorov-Smirnov test
+        res = ks_2samp(first_list, second_list)
+        return res
+
+    def extract_list(self, s: Set) -> list[int]:
+        metadata_values = []
+
+        for element in s.get_elements():
+            if isinstance(element, Repository):
+                repo: Repository = element
+                metadata_value = repo.get_metadata_value(self.metadata)
+                if metadata_value:
+                    metadata_values.append(metadata_value.get_value())
+
+        return metadata_values

sampling_mining_workflows_dsl/constraint/BoolComparator.py

@@ -0,0 +1,23 @@
+from collections.abc import Callable
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.constraint.Comparator import Comparator
+from sampling_mining_workflows_dsl.element.Element import Element
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+T = TypeVar("T")
+
+
+class BoolComparator[T](Comparator[T]):
+    def __init__(
+        self, targeted_metadata: Metadata[T], comparator: Callable[[T, T], T] = None
+    ):
+        super().__init__(targeted_metadata)
+        self.comparator = comparator
+
+    def compare(self, a: Element, b: Element) -> Element:
+        a_value = a.get_metadata_value(self.targeted_metadata).get_value()
+        b_value = b.get_metadata_value(self.targeted_metadata).get_value()
+        result = self.comparator(a_value, b_value)
+
+        return a if result == a_value else b

sampling_mining_workflows_dsl/constraint/BoolConstraint.py

@@ -0,0 +1,50 @@
+from collections.abc import Callable
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.constraint.Constraint import Constraint
+from sampling_mining_workflows_dsl.element.Element import Element
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+T = TypeVar("T")
+
+
+class BoolConstraint(Constraint[T]):
+    def __init__(
+        self,
+        workflow,
+        constraint: Callable[[tuple[T, ...]], bool],
+        *targeted_metadatas: tuple[Metadata[T], ...],
+    ):
+        super().__init__(workflow, *targeted_metadatas)
+        self.constraint = constraint
+        self.or_constraint: Constraint | None = None
+        self.and_constraint: Constraint | None = None
+
+    def is_satisfied(self, element: Element) -> bool:
+        if self.or_constraint is not None and self.and_constraint is not None:
+            raise RuntimeError("Both 'and' & 'or' constraints are defined")
+
+        value_objs = [
+            element.get_metadata_value(target_metadata).get_value()
+            for target_metadata in self.targeted_metadatas
+        ]
+        # TODO add type check
+        # if not isinstance(value_objs, self.targeted_metadatas.type):
+        #     raise RuntimeError(f"Unexpected metadata type: {type(value_objs)}")
+
+        constraint_result = self.constraint(*value_objs)
+
+        if self.or_constraint is not None:
+            return constraint_result or self.or_constraint.is_satisfied(element)
+        if self.and_constraint is not None:
+            return constraint_result and self.and_constraint.is_satisfied(element)
+
+        return constraint_result
+
+    def or_(self, other: "BoolConstraint") -> "BoolConstraint":
+        self.or_constraint = other
+        return other
+
+    def and_(self, other: "BoolConstraint") -> "BoolConstraint":
+        self.and_constraint = other
+        return other