scitex 2.0.0__py2.py3-none-any.whl

scitex/io/_save_modules/_listed_scalars_as_csv.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 14:53:11 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_save_modules/_save_listed_scalars_as_csv.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/io/_save_modules/_save_listed_scalars_as_csv.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+# Time-stamp: "2024-11-02 21:26:48 (ywatanabe)"
+
+import numpy as np
+import pandas as pd
+
+from .._mv_to_tmp import _mv_to_tmp
+
+
+
+def _save_listed_scalars_as_csv(
+    listed_scalars,
+    spath_csv,
+    column_name="_",
+    indi_suffix=None,
+    round=3,
+    overwrite=False,
+    verbose=False,
+):
+    """Puts to df and save it as csv"""
+
+    if overwrite == True:
+        _mv_to_tmp(spath_csv, L=2)
+    indi_suffix = np.arange(len(listed_scalars)) if indi_suffix is None else indi_suffix
+    df = pd.DataFrame(
+        {"{}".format(column_name): listed_scalars}, index=indi_suffix
+    ).round(round)
+    df.to_csv(spath_csv)
+    if verbose:
+        print("\nSaved to: {}\n".format(spath_csv))
+
+# EOF

scitex/io/_save_modules/_matlab.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:28:15 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_matlab.py
+
+import scipy.io
+
+
+def _save_matlab(obj, spath):
+    """
+    Save a Python dictionary to a MATLAB .mat file.
+    
+    Parameters
+    ----------
+    obj : dict
+        Dictionary of arrays to save in MATLAB format.
+    spath : str
+        Path where the MATLAB file will be saved.
+        
+    Returns
+    -------
+    None
+    """
+    scipy.io.savemat(spath, obj)

scitex/io/_save_modules/_mp4.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 16:57:29 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/io/_save_mp4.py
+
+from matplotlib import animation
+
+
+def _mk_mp4(fig, spath_mp4):
+    axes = fig.get_axes()
+
+    def init():
+        return (fig,)
+
+    def animate(i):
+        for ax in axes:
+            ax.view_init(elev=10.0, azim=i)
+        return (fig,)
+
+    anim = animation.FuncAnimation(
+        fig, animate, init_func=init, frames=360, interval=20, blit=True
+    )
+
+    writermp4 = animation.FFMpegWriter(fps=60, extra_args=["-vcodec", "libx264"])
+    anim.save(spath_mp4, writer=writermp4)
+    print("\nSaving to: {}\n".format(spath_mp4))
+
+
+# EOF

scitex/io/_save_modules/_numpy.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:19:07 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_numpy.py
+
+import numpy as np
+
+
+def _save_npy(obj, spath):
+    """
+    Save a numpy array to .npy format.
+    
+    Parameters
+    ----------
+    obj : numpy.ndarray
+        The numpy array to save.
+    spath : str
+        Path where the .npy file will be saved.
+        
+    Returns
+    -------
+    None
+    """
+    np.save(spath, obj)
+
+
+def _save_npz(obj, spath):
+    """
+    Save numpy arrays to .npz format.
+    
+    Parameters
+    ----------
+    obj : dict or list/tuple of numpy.ndarray
+        Either a dictionary of arrays or a list/tuple of arrays.
+    spath : str
+        Path where the .npz file will be saved.
+        
+    Returns
+    -------
+    None
+    
+    Raises
+    ------
+    ValueError
+        If obj is not a dict of arrays or a list/tuple of arrays.
+    """
+    if isinstance(obj, dict):
+        np.savez_compressed(spath, **obj)
+    elif isinstance(obj, (list, tuple)) and all(
+        isinstance(x, np.ndarray) for x in obj
+    ):
+        obj = {str(ii): obj[ii] for ii in range(len(obj))}
+        np.savez_compressed(spath, **obj)
+    else:
+        raise ValueError(
+            "For .npz files, obj must be a dict of arrays or a list/tuple of arrays."
+        )

scitex/io/_save_modules/_optuna_study_as_csv_and_pngs.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 17:01:15 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/io/_save_optuna_study_as_csv_and_pngs.py
+
+
+def save_optuna_study_as_csv_and_pngs(study, sdir):
+    import optuna
+    from .._save import save
+
+    ## Trials DataFrame
+    trials_df = study.trials_dataframe()
+
+    ## Figures
+    hparams_keys = list(study.best_params.keys())
+    slice_plot = optuna.visualization.plot_slice(study, params=hparams_keys)
+    contour_plot = optuna.visualization.plot_contour(study, params=hparams_keys)
+    optim_hist_plot = optuna.visualization.plot_optimization_history(study)
+    parallel_coord_plot = optuna.visualization.plot_parallel_coordinate(
+        study, params=hparams_keys
+    )
+    hparam_importances_plot = optuna.visualization.plot_param_importances(study)
+    figs_dict = dict(
+        slice_plot=slice_plot,
+        contour_plot=contour_plot,
+        optim_hist_plot=optim_hist_plot,
+        parallel_coord_plot=parallel_coord_plot,
+        hparam_importances_plot=hparam_importances_plot,
+    )
+
+    ## Saves
+    save(trials_df, sdir + "trials_df.csv")
+
+    for figname, fig in figs_dict.items():
+        save(fig, sdir + f"{figname}.png")
+
+
+# EOF

scitex/io/_save_modules/_pickle.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:21:07 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_pickle.py
+
+import pickle
+import gzip
+
+
+def _save_pickle(obj, spath):
+    """
+    Save an object using Python's pickle serialization.
+    
+    Parameters
+    ----------
+    obj : Any
+        Object to serialize.
+    spath : str
+        Path where the pickle file will be saved.
+        
+    Returns
+    -------
+    None
+    """
+    with open(spath, "wb") as s:
+        pickle.dump(obj, s)
+
+
+def _save_pickle_gz(obj, spath):
+    """
+    Save an object using Python's pickle serialization with gzip compression.
+    
+    Parameters
+    ----------
+    obj : Any
+        Object to serialize.
+    spath : str
+        Path where the compressed pickle file will be saved.
+        
+    Returns
+    -------
+    None
+    """
+    with gzip.open(spath, "wb") as f:
+        pickle.dump(obj, f)

scitex/io/_save_modules/_plotly.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:30:15 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_plotly.py
+
+import plotly
+
+
+def _save_plotly_html(obj, spath):
+    """
+    Save a Plotly figure as an HTML file.
+    
+    Parameters
+    ----------
+    obj : plotly.graph_objs.Figure
+        The Plotly figure to save.
+    spath : str
+        Path where the HTML file will be saved.
+        
+    Returns
+    -------
+    None
+    """
+    if isinstance(obj, plotly.graph_objs.Figure):
+        obj.write_html(file=spath)
+    else:
+        raise TypeError("Object must be a plotly.graph_objs.Figure")

scitex/io/_save_modules/_text.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:17:12 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_text.py
+
+
+def _save_text(obj, spath):
+    """
+    Save text content to a file.
+    
+    Parameters
+    ----------
+    obj : str
+        The text content to save.
+    spath : str
+        Path where the text file will be saved.
+        
+    Returns
+    -------
+    None
+    """
+    with open(spath, "w") as file:
+        file.write(obj)

scitex/io/_save_modules/_torch.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:25:14 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_torch.py
+
+import torch
+
+
+def _save_torch(obj, spath, **kwargs):
+    """
+    Save a PyTorch model or tensor.
+    
+    Parameters
+    ----------
+    obj : torch.nn.Module or torch.Tensor
+        The PyTorch model or tensor to save.
+    spath : str
+        Path where the PyTorch file will be saved.
+    **kwargs : dict
+        Additional keyword arguments to pass to torch.save.
+        
+    Returns
+    -------
+    None
+    """
+    torch.save(obj, spath, **kwargs)

scitex/io/_save_modules/_yaml.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:26:16 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_yaml.py
+
+from ruamel.yaml import YAML
+
+
+def _save_yaml(obj, spath):
+    """
+    Save a Python object as a YAML file.
+    
+    Parameters
+    ----------
+    obj : dict
+        The object to serialize to YAML.
+    spath : str
+        Path where the YAML file will be saved.
+        
+    Returns
+    -------
+    None
+    """
+    yaml = YAML()
+    yaml.preserve_quotes = True
+    yaml.indent(mapping=4, sequence=4, offset=4)
+
+    with open(spath, "w") as f:
+        yaml.dump(obj, f)

scitex/life/__init__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Scitex life module."""
+
+from ._monitor_rain import check_rain, monitor_rain, notify_rain
+
+__all__ = [
+    "check_rain",
+    "monitor_rain",
+    "notify_rain",
+]

scitex/life/_monitor_rain.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 14:20:28 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/life/_monitor_rain.py
+
+"""Imports"""
+import time
+
+import requests
+import warnings
+
+try:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", UserWarning)
+        from plyer import notification
+except:
+    pass
+
+"""Functions & Classes"""
+API_KEY = "your_api_key"
+CITY = "your_city"
+API_URL = f"http://api.openweathermap.org/data/2.5/weather?q={CITY}&appid={API_KEY}"
+
+
+def check_rain():
+    response = requests.get(API_URL)
+    data = response.json()
+    if "rain" in data:
+        notify_rain()
+
+
+def notify_rain():
+    notification.notify(
+        title="Rain Alert",
+        message="It's starting to rain in your area!",
+        timeout=10,
+    )
+
+
+def monitor_rain():
+    while True:
+        check_rain()
+        time.sleep(300)  # Check every 5 minutes
+
+
+if __name__ == "__main__":
+    monitor_rain()
+
+# EOF

scitex/linalg/__init__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+"""Linear algebra utilities module for scitex."""
+
+from ._distance import euclidean_distance, cdist, edist
+from ._geometric_median import geometric_median
+from ._misc import cosine, nannorm, rebase_a_vec, three_line_lengths_to_coords
+
+__all__ = [
+    "euclidean_distance",
+    "cdist",
+    "edist", 
+    "geometric_median",
+    "cosine",
+    "nannorm",
+    "rebase_a_vec",
+    "three_line_lengths_to_coords",
+]

scitex/linalg/_distance.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-04 02:58:04 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/linalg/_distance.py
+
+import numpy as np
+import scipy.spatial.distance as _distance
+
+from ..decorators._numpy_fn import numpy_fn
+from ..decorators._wrap import wrap
+
+
+@numpy_fn
+def euclidean_distance(uu, vv, axis=0):
+    """
+    Compute the Euclidean distance between two arrays along the specified axis.
+
+    Parameters
+    ----------
+    uu : array_like
+        First input array.
+    vv : array_like
+        Second input array.
+    axis : int, optional
+        Axis along which to compute the distance. Default is 0.
+
+    Returns
+    -------
+    array_like
+        Euclidean distance array along the specified axis.
+    """
+    uu, vv = np.atleast_1d(uu), np.atleast_1d(vv)
+
+    if uu.shape[axis] != vv.shape[axis]:
+        raise ValueError(f"Shape along axis {axis} must match")
+
+    uu = np.moveaxis(uu, axis, 0)
+    vv = np.moveaxis(vv, axis, 0)
+
+    uu_tgt_shape = [uu.shape[0]] + list(uu.shape[1:]) + [1] * (vv.ndim - 1)
+    vv_tgt_shape = [vv.shape[0]] + [1] * (uu.ndim - 1) + list(vv.shape[1:])
+
+    uu_reshaped = uu.reshape(uu_tgt_shape)
+    vv_reshaped = vv.reshape(vv_tgt_shape)
+
+    diff = uu_reshaped - vv_reshaped
+    euclidean_dist = np.sqrt(np.sum(diff**2, axis=axis))
+    return euclidean_dist
+
+
+@wrap
+def cdist(*args, **kwargs):
+    return _distance.cdist(*args, **kwargs)
+
+
+edist = euclidean_distance
+
+# Optionally, manually copy the original docstring
+# euclidean_distance.__doc__ = _distance.euclidean.__doc__
+cdist.__doc__ = _distance.cdist.__doc__
+
+
+# EOF

scitex/linalg/_geometric_median.py

@@ -0,0 +1,64 @@
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-09-26 19:41:01 (ywatanabe)"
+# /home/ywatanabe/proj/scitex/src/scitex/linalg/_geometric_median.py
+
+
+"""
+This script does XYZ.
+"""
+
+import torch
+from geom_median.torch import compute_geometric_median
+from ..decorators import torch_fn
+
+# @torch_fn
+# def geometric_median(xx, dim=-1):
+#     indi = [slice(None) for _ in range(xx.ndim)]
+#     indi[dim] = slice(None)
+#     xx[indi]  # how can I loop over the designated dim??
+
+#     return compute_geometric_median(xx).median
+
+
+@torch_fn
+def geometric_median(xx, dim=-1):
+
+    # Ensure dim is a positive index
+    if dim < 0:
+        dim = xx.ndim + dim
+        dim = torch.tensor(dim).to(xx.device)
+
+    # Create a list of slices to access all elements along each dimension
+    indi = [slice(None)] * xx.ndim
+
+    # Get the size of the dimension we want to loop over
+    dim_size = xx.shape[dim]
+
+    points = []
+    # Loop over each index in the specified dimension
+    for i in range(dim_size):
+        indi[dim] = i
+        # Set the slice for the current index in the target dimension
+        slice_data = xx[tuple(indi)]  # Extract the data for the current index
+        points.append(slice_data)
+
+    out = compute_geometric_median(points).median
+
+    return out
+
+
+if __name__ == "__main__":
+    # # Argument Parser
+    # import argparse
+    # parser = argparse.ArgumentParser(description='')
+    # parser.add_argument('--var', '-v', type=int, default=1, help='')
+    # parser.add_argument('--flag', '-f', action='store_true', default=False, help='')
+    # args = parser.parse_args()
+
+    # Main
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, verbose=False)
+    main()
+    scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+# EOF

scitex/linalg/_misc.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2023-03-17 21:30:11 (ywatanabe)"
+
+import numpy as np
+import sympy
+from scipy.linalg import norm
+
+
+def cosine(v1, v2):
+    if np.isnan(v1).any():
+        return np.nan
+    if np.isnan(v2).any():
+        return np.nan
+    return np.dot(v1, v2) / (norm(v1) * norm(v2))
+
+
+def nannorm(v, axis=-1):
+    if np.isnan(v).any():
+        return np.nan
+    else:
+        return norm(v, axis=axis)
+
+
+def rebase_a_vec(v, v_base):
+    def production_vector(v1, v0):
+        """
+        production_vector(np.array([3,4]), np.array([10,0])) # np.array([3, 0])
+        """
+        return norm(v1) * cosine(v1, v0) * v0 / norm(v0)
+
+    if np.isnan(v).any():
+        return np.nan
+    if np.isnan(v_base).any():
+        return np.nan
+    v_prod = production_vector(v, v_base)
+    sign = np.sign(cosine(v, v_base))
+    return sign * norm(v_prod)
+
+
+def three_line_lengths_to_coords(aa, bb, cc):
+    """
+    O, A, B = three_line_lengths_to_coords(2, np.sqrt(3), 1)
+    print(O, A, B)
+    """
+
+    # Definition
+    a1 = sympy.Symbol("a1")
+    b1 = sympy.Symbol("b1")
+    b2 = sympy.Symbol("b2")
+
+    a1 = aa
+    # b1 = bb
+
+    # Calculates
+    cos = (aa**2 + bb**2 - cc**2) / (2 * aa * bb)
+    sin = np.sqrt(1 - cos**2)
+    S1 = 1 / 2 * aa * bb * sin
+    S2 = 1 / 2 * aa * b2
+
+    # Solves
+    b2 = sympy.solve(S1 - S2)[0]
+    b1 = bb * cos
+
+    # tan1 = b2 / b1
+    # tan2 = sin/cos
+
+    # b1 = sympy.solve(tan1-tan2)[0]
+    O = (0, 0, 0)
+    A = (a1, 0, 0)
+    B = (b1, b2, 0)
+
+    return O, A, B

scitex/nn/_AxiswiseDropout.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-03-30 07:27:27 (ywatanabe)"
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class AxiswiseDropout(nn.Module):
+    def __init__(self, dropout_prob=0.5, dim=1):
+        super(AxiswiseDropout, self).__init__()
+        self.dropout_prob = dropout_prob
+        self.dim = dim
+
+    def forward(self, x):
+        if self.training:
+            sizes = [s if i == self.dim else 1 for i, s in enumerate(x.size())]
+            dropout_mask = F.dropout(
+                torch.ones(*sizes, device=x.device, dtype=x.dtype),
+                self.dropout_prob,
+                True,
+            )
+
+            # Expand the mask to the size of the input tensor and apply it
+            return x * dropout_mask.expand_as(x)
+        return x