localgraph 0.1.0__tar.gz

localgraph-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Omar Melikechi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

localgraph-0.1.0/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: localgraph
+Version: 0.1.0
+Summary: Local graph estimation with pathwise feature selection
+Author: Omar Melikechi
+Author-email: omar.melikechi@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ipss>=1.1.1
+Requires-Dist: matplotlib>=3.0.0
+Requires-Dist: networkx>=2.0
+Requires-Dist: numpy>=1.16.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Local graph estimation with pathwise feature selection
+
+> **Local graph estimation** is a framework for discovering local graph/network structure around specific variables of interest. **Pathwise feature selection (PFS)** is an algorithm for performing local graph estimation with pathwise false discovery control.
+
+## Associated paper
+
+- **Local graph estimation: Interpretable network discovery for complex data**  
+	In preparation
+
+## Installation
+```
+pip install localgraph
+```
+
+## Usage
+```python
+from localgraph import pfs, plot_graph
+
+# Load n-by-p data matrix X (n samples, p features)
+
+# Specify the target features (list of indices)
+target_features = [0, 1]
+
+# Specify the pathwise q-value threshold
+qpath_max = 0.2
+
+# Optional: specify the maximum radius of the local graph (default is 3)
+max_radius = 3
+
+# Optional: specify the neighborhood FDR thresholds for nodes in each radius
+fdr_local = [0.2, 0.1, 0.1]
+
+# Run PFS
+Q = pfs(X, target_features, qpath_max=qpath_max, max_radius=max_radius, fdr_local=fdr_local)
+
+# Plot the estimated subgraph
+plot_graph(graph=Q, target_features=target_features, radius=max_radius)
+```
+
+### Outputs
+- `Q`: Dictionary mapping edges `(i,j)` to q-values. Edges are undirected, so `(i,j)` and `(j,i)` are included.
+
+### What PFS does
+- Expands the local graph outward, layer by layer, starting from target variables.
+- Performs neighborhood selection with FDR control using [**integrated path stability selection**](https://github.com/omelikechi/ipss).
+- Controls pathwise false discoveries by summing q-values along candidate paths.
+
+## Full list of `pfs` arguments
+
+### Required arguments:
+- `X`: n-by-p data matrix (NumPy array). Each column is a feature/variable.
+- `target_features`: Feature index or list of indices to center the graph around.
+- `qpath_max`: Maximum allowed sum of q-values along any path.
+
+### Optional arguments:
+- `max_radius`: Maximum number of expansion layers around each target (int; default `3`).
+- `fdr_local`: Neighborhood FDR threshold at each radius (list of length `max_radius`; default `[qpath_max]*max_radius`).
+- `custom_nbhd`: Dictionary specifying custom FDR cutoffs for certain features (dict; default `None`).
+- `feature_names`: List of feature names; required if `custom_nbhd` is provided (list of strings).
+- `criterion`: Rule for resolving multiple edges (default `'min'`).
+- `selector`: Feature importance method used by IPSS (str; default `'gb'`). Options:
+	- `'gb'`: Gradient boosting
+	- `'l1'`: L1-regularized regression (lasso)
+	- `'rf'`: Random forest
+	- Custom function (see `ipss_args`)
+- `ipss_args`: Dictionary of arguments to pass to `ipss` (dict; default `None`)
+- `verbose`: Whether to print progress during selection (bool; default `False`)
+
+## Graph plotting
+
+Use `plot_graph` to visualize a local graph up to the specified `radius` around one or more target features.
+
+```python
+from localgraph import plot_graph
+
+# Plot local graph around target_features using output Q from pfs
+plot_graph(graph=Q, target_features=target_features, radius=3)
+```
+
+### Features and customization
+`plot_graph` visualizes a local graph of a user-specified radius around one or more target features. It supports:
+- Flexible input formats: edge dictionary, adjacency matrix, or NetworkX graph
+- Automatic subgraph extraction around the targets
+- Node coloring by distance from the target(s) (default), or user-specified colors (e.g., by variable type)
+- Several layout algorithms (`'kamada_kawai'`, `'spring'`, `'circular'`, etc.)
+- Customizable node size, font sizes, and edge thickness
+- Optional display of q-values; edge widths can reflect q-value strength (`edge_widths='q_value'`)
+- False positives shown in red if the true graph is provided
+- Integration with custom plots via `ax` or `pos`
+- Optional saving of figures (`save_fig`) and graphs (`save_graph`)
+
+For a full list of arguments, see the [`plot_graph`](./localgraph/plotting/plot_graph.py) docstring.
+
+### Returns
+The function returns a dictionary containing:
+- `feature_radius_list`: List of `(feature name, radius)` pairs for all nodes in the graph.
+- `graph`: The NetworkX subgraph used for plotting.
+- `positions`: Dictionary of node coordinates.
+- `figure`: The matplotlib figure object (only if the function creates the figure).
+
+### Further customization
+
+To manually adjust node positions for publication-quality figures, you can export graphs to [**Gephi**](https://gephi.org/), edit them interactively, and re-import the updated layout into Python. See: [gephi_instructions.md](./gephi_instructions.md) for a full walkthrough.
+
+## Examples
+
+The `examples/` folder contains scripts that demonstrate end-to-end usage:
+
+- `simple_example.py`: Simulate data, run PFS, and visualize the result.
+
+## Evaluation tools
+
+The `evaluation/` folder contains helper functions for measuring subgraph recovery in simulation settings.
+
+- The `eval.py` script contains two functions:
+	- `subgraph_within_radius`: Extract true subgraph around a target node (useful for identifying subgraphs within full graphs)
+	- `tp_and_fp`: Count true and false positives compared to ground truth
+
+These are useful for benchmarking PFS and other graph estimation methods when the true graph is known.
+
+
+
+
+
+
+
+
+
+

localgraph-0.1.0/README.md

@@ -0,0 +1,129 @@
+# Local graph estimation with pathwise feature selection
+
+> **Local graph estimation** is a framework for discovering local graph/network structure around specific variables of interest. **Pathwise feature selection (PFS)** is an algorithm for performing local graph estimation with pathwise false discovery control.
+
+## Associated paper
+
+- **Local graph estimation: Interpretable network discovery for complex data**  
+	In preparation
+
+## Installation
+```
+pip install localgraph
+```
+
+## Usage
+```python
+from localgraph import pfs, plot_graph
+
+# Load n-by-p data matrix X (n samples, p features)
+
+# Specify the target features (list of indices)
+target_features = [0, 1]
+
+# Specify the pathwise q-value threshold
+qpath_max = 0.2
+
+# Optional: specify the maximum radius of the local graph (default is 3)
+max_radius = 3
+
+# Optional: specify the neighborhood FDR thresholds for nodes in each radius
+fdr_local = [0.2, 0.1, 0.1]
+
+# Run PFS
+Q = pfs(X, target_features, qpath_max=qpath_max, max_radius=max_radius, fdr_local=fdr_local)
+
+# Plot the estimated subgraph
+plot_graph(graph=Q, target_features=target_features, radius=max_radius)
+```
+
+### Outputs
+- `Q`: Dictionary mapping edges `(i,j)` to q-values. Edges are undirected, so `(i,j)` and `(j,i)` are included.
+
+### What PFS does
+- Expands the local graph outward, layer by layer, starting from target variables.
+- Performs neighborhood selection with FDR control using [**integrated path stability selection**](https://github.com/omelikechi/ipss).
+- Controls pathwise false discoveries by summing q-values along candidate paths.
+
+## Full list of `pfs` arguments
+
+### Required arguments:
+- `X`: n-by-p data matrix (NumPy array). Each column is a feature/variable.
+- `target_features`: Feature index or list of indices to center the graph around.
+- `qpath_max`: Maximum allowed sum of q-values along any path.
+
+### Optional arguments:
+- `max_radius`: Maximum number of expansion layers around each target (int; default `3`).
+- `fdr_local`: Neighborhood FDR threshold at each radius (list of length `max_radius`; default `[qpath_max]*max_radius`).
+- `custom_nbhd`: Dictionary specifying custom FDR cutoffs for certain features (dict; default `None`).
+- `feature_names`: List of feature names; required if `custom_nbhd` is provided (list of strings).
+- `criterion`: Rule for resolving multiple edges (default `'min'`).
+- `selector`: Feature importance method used by IPSS (str; default `'gb'`). Options:
+	- `'gb'`: Gradient boosting
+	- `'l1'`: L1-regularized regression (lasso)
+	- `'rf'`: Random forest
+	- Custom function (see `ipss_args`)
+- `ipss_args`: Dictionary of arguments to pass to `ipss` (dict; default `None`)
+- `verbose`: Whether to print progress during selection (bool; default `False`)
+
+## Graph plotting
+
+Use `plot_graph` to visualize a local graph up to the specified `radius` around one or more target features.
+
+```python
+from localgraph import plot_graph
+
+# Plot local graph around target_features using output Q from pfs
+plot_graph(graph=Q, target_features=target_features, radius=3)
+```
+
+### Features and customization
+`plot_graph` visualizes a local graph of a user-specified radius around one or more target features. It supports:
+- Flexible input formats: edge dictionary, adjacency matrix, or NetworkX graph
+- Automatic subgraph extraction around the targets
+- Node coloring by distance from the target(s) (default), or user-specified colors (e.g., by variable type)
+- Several layout algorithms (`'kamada_kawai'`, `'spring'`, `'circular'`, etc.)
+- Customizable node size, font sizes, and edge thickness
+- Optional display of q-values; edge widths can reflect q-value strength (`edge_widths='q_value'`)
+- False positives shown in red if the true graph is provided
+- Integration with custom plots via `ax` or `pos`
+- Optional saving of figures (`save_fig`) and graphs (`save_graph`)
+
+For a full list of arguments, see the [`plot_graph`](./localgraph/plotting/plot_graph.py) docstring.
+
+### Returns
+The function returns a dictionary containing:
+- `feature_radius_list`: List of `(feature name, radius)` pairs for all nodes in the graph.
+- `graph`: The NetworkX subgraph used for plotting.
+- `positions`: Dictionary of node coordinates.
+- `figure`: The matplotlib figure object (only if the function creates the figure).
+
+### Further customization
+
+To manually adjust node positions for publication-quality figures, you can export graphs to [**Gephi**](https://gephi.org/), edit them interactively, and re-import the updated layout into Python. See: [gephi_instructions.md](./gephi_instructions.md) for a full walkthrough.
+
+## Examples
+
+The `examples/` folder contains scripts that demonstrate end-to-end usage:
+
+- `simple_example.py`: Simulate data, run PFS, and visualize the result.
+
+## Evaluation tools
+
+The `evaluation/` folder contains helper functions for measuring subgraph recovery in simulation settings.
+
+- The `eval.py` script contains two functions:
+	- `subgraph_within_radius`: Extract true subgraph around a target node (useful for identifying subgraphs within full graphs)
+	- `tp_and_fp`: Count true and false positives compared to ground truth
+
+These are useful for benchmarking PFS and other graph estimation methods when the true graph is known.
+
+
+
+
+
+
+
+
+
+

localgraph-0.1.0/localgraph/__init__.py

@@ -0,0 +1,8 @@
+# localgraph/__init__.py
+
+from localgraph.evaluation.eval import tp_and_fp, subgraph_within_radius
+from localgraph.pfs.helpers import lightest_paths, prune_graph
+from localgraph.pfs.main import pfs
+from localgraph.plotting.plot_graph import plot_graph
+
+__all__ = ['lightest_paths', 'pfs', 'plot_graph', 'prune_graph', 'subgraph_within_radius', 'tp_and_fp']

localgraph-0.1.0/localgraph/evaluation/eval.py

@@ -0,0 +1,151 @@
+# Functions for evaluating local graph estimation performance
+
+from collections import deque
+
+import numpy as np
+
+def subgraph_within_radius(A, target_nodes, radius):
+	"""
+	Returns a subgraph of nodes and edges that are at most `radius` distance from the target nodes.
+
+	Parameters:
+	- A: Adjacency matrix (numpy array) of the graph.
+	- radius: Maximum distance from the target nodes.
+	- target_nodes: List of target node indices.
+
+	Returns:
+	- A_r: Symmetric adjacency matrix of the subgraph.
+	"""
+	n = A.shape[0]  # Number of nodes in the graph
+	visited = set()  # Nodes within the radius
+	queue = deque()
+
+	if isinstance(target_nodes, int):
+		target_nodes = [target_nodes]
+
+	# Initialize the queue with target nodes
+	for node in target_nodes:
+		queue.append((node, 0))  # (node, distance from target)
+		visited.add(node)
+
+	# Perform BFS to find all nodes within the radius
+	while queue:
+		current_node, current_distance = queue.popleft()
+		if current_distance >= radius:
+			continue  # Stop if we exceed the radius
+
+		# Explore neighbors
+		for neighbor in np.where(A[current_node] > 0)[0]:
+			if neighbor not in visited:
+				visited.add(neighbor)
+				queue.append((neighbor, current_distance + 1))
+
+	# Create the subgraph adjacency matrix
+	visited = sorted(visited)  # Sort for consistent indexing
+	A_r = np.zeros_like(A)  # Initialize the subgraph matrix
+
+	# Fill the subgraph matrix
+	for i in visited:
+		for j in visited:
+			A_r[i, j] = A[i, j]  # Copy edges from the original graph
+
+	return A_r
+
+def tp_and_fp(A, A_true, target_features, radius=None):
+	"""
+	Compute the number of true and false edges in an estimated graph
+
+	Parameters:
+	- A : dict or np.ndarray
+		Estimated adjacency structure, either as a dictionary of edge q-values 
+		or a binary adjacency matrix.
+	- A_true : np.ndarray
+		Ground-truth binary adjacency matrix.
+	- target_features : list of int
+		Indices of target nodes around which the local subgraph is evaluated.
+	- radius : int or None, optional
+		Radius of the local neighborhood around target features. If None, counts
+		are computed over the full graph.
+
+	Returns:
+	- tp : int
+		Number of true positive edges.
+	- fp : int
+		Number of false positive edges.
+
+	Notes:
+		- If `radius` is specified, edges are evaluated within the radius neighborhood 
+			of target nodes, excluding edges between two nodes at the outermost radius.
+	"""
+
+	# Convert dictionary of q-values to a matrix
+	if isinstance(A, dict):
+		p = A_true.shape[0]
+		A_matrix = np.zeros((p,p))
+		for (i,j), q in A.items():
+			A_matrix[i,j] = q
+			A_matrix[j,i] = q
+		A = A_matrix
+
+	A = (A != 0).astype(int)
+	p = A.shape[0]
+	if not np.all(A == A.T):
+		num_asymmetric = np.sum(A != A.T)
+		max_diff = np.max(np.abs(A - A.T))
+		print(f"A is not symmetric: {num_asymmetric} asymmetric entries.")
+		print(f"Maximum absolute difference: {max_diff}")
+		raise ValueError(f'A is not symmetric.')
+	if not np.all(A_true == A_true.T):
+		raise ValueError(f'A_true is not symmetric.')
+
+	if radius is None:
+		tp, fp = 0, 0
+		for i in range(p):
+			for j in range(i+1,p):
+				if A[i,j] == 1:
+					if A_true[i,j] == 1:
+						tp += 1
+					else:
+						fp += 1
+	else:
+		A_true = subgraph_within_radius(A_true, target_features, radius)
+
+		visited = np.zeros(p, dtype=bool)
+		nodes_within_radius = set()
+		nodes_at_outer_radius = set()
+
+		# Perform BFS to identify all nodes within the given radius
+		for target in target_features:
+			queue = deque([(target, 0)])  # (node, current_distance)
+			while queue:
+				node, dist = queue.popleft()
+				if dist > radius or visited[node]:
+					continue
+				visited[node] = True
+				if dist < radius:
+					nodes_within_radius.add(node)
+				elif dist == radius:
+					nodes_at_outer_radius.add(node)
+
+				for neighbor in range(p):
+					if A[node, neighbor] == 1 and not visited[neighbor]:
+						queue.append((neighbor, dist + 1))
+
+		# Reset visited to reuse for the TP/FP calculation
+		visited.fill(False)
+
+		tp, fp = 0, 0
+		# Check edges in the subgraph, but **exclude edges between two outer radius nodes**
+		for i in nodes_within_radius | nodes_at_outer_radius:
+			for j in range(i + 1, p):  # Upper triangular part
+				if j in nodes_within_radius | nodes_at_outer_radius and A[i, j] == 1:
+					if i in nodes_at_outer_radius and j in nodes_at_outer_radius:
+						continue  # Exclude edges between outer radius nodes
+					if A_true[i, j] == 1:
+						tp += 1
+					else:
+						fp += 1
+
+	return tp, fp
+
+

localgraph-0.1.0/localgraph/examples/simple_example.py

@@ -0,0 +1,66 @@
+# A simple example of local graph estimation with pathwise feature selection (PFS)
+
+from localgraph import pfs, plot_graph
+import matplotlib.pyplot as plt
+import numpy as np
+
+#--------------------------------
+# Setup
+#--------------------------------
+np.random.seed(302)
+n, p = 100, 50
+
+#--------------------------------
+# Generate true graph and samples
+#--------------------------------
+# define nonlinear function
+def f(x):
+	return np.exp(-x**2 / 2)
+
+# generate data
+def generate_data(n, p, target_feature=0, snr=2):
+	X = np.random.normal(0, 1, size=(n,p))
+
+	# radius 2 (linear realtionships)
+	X[:,1] += X[:,3] + X[:,5]
+	X[:,2] += X[:,4] + X[:,6]
+
+	# radius 1 (nonlinear relationships)
+	signal = f(X[:,1]) + f(X[:,2])
+	sigma2 = np.var(signal) / snr
+	X[:,target_feature] = signal + np.random.normal(0, np.sqrt(sigma2), size=n)
+
+	# Construct true adjacency matrix
+	A_true = np.zeros((p,p))
+	true_edges = [(3,1), (5,1), (4,2), (6,2), (1,target_feature), (2,target_feature)]
+	for i, j in true_edges:
+		A_true[i,j] = 1
+		A_true[j,i] = 1
+
+	return X, target_feature, A_true
+
+# generate data
+X, target_feature, A_true = generate_data(n,p)
+
+#--------------------------------
+# Run PFS
+#--------------------------------
+qpath_max = 0.1
+max_radius = 2
+Q = pfs(X, target_feature, qpath_max=qpath_max, max_radius=max_radius, verbose=True)
+
+#--------------------------------
+# Plot true and estimated local graphs
+#--------------------------------
+fig, axes = plt.subplots(1, 2, figsize=(18,8))
+
+# Plot true graph
+plot_graph(graph=A_true, target_features=target_feature, radius=max_radius, edge_widths=3, ax=axes[0], show_weights=False)
+axes[0].set_title('True Graph', fontsize=24)
+
+# Plot estimated graph
+plot_graph(graph=Q, target_features=target_feature, radius=max_radius, true_graph=A_true, edge_widths=3, ax=axes[1])
+axes[1].set_title('Estimated Graph', fontsize=24)
+
+plt.tight_layout()
+plt.show()

localgraph-0.1.0/localgraph/pfs/__init__.py

@@ -0,0 +1,2 @@
+
+

localgraph-0.1.0/localgraph/pfs/helpers.py

@@ -0,0 +1,140 @@
+# Helper functions for the main PFS function, main.py
+
+import heapq
+
+
+def lightest_paths(Q, target_features, new_features):
+	"""
+	Computes the lightest path (minimum cumulative q-value) from any target feature 
+	to all new features using Dijkstra's algorithm.
+
+	Parameters:
+		Q (dict): Dictionary of edge q-values {(i, j): q}.
+		target_features (set): Set of initial target features.
+		new_features (set): Set of features for which to compute the lightest paths.
+
+	Returns:
+		dict: {feature: minimum cumulative q-value path} for all new_features.
+	"""
+	if isinstance(target_features, int):
+		target_features = [target_features]
+
+	pq = [(0, f) for f in target_features]  # Priority queue: (cumulative q-value, feature)
+	heapq.heapify(pq)
+	min_q_path = {f: 0 for f in target_features}  # Store minimum path values
+
+	while pq:
+		q_path, feature = heapq.heappop(pq)
+
+		# Stop early if all new_features have been reached
+		if new_features.issubset(min_q_path):
+			break
+
+		for neighbor in {j for i, j in Q.keys() if i == feature} | {i for i, j in Q.keys() if j == feature}:
+			q_edge = Q[(feature, neighbor)]
+			new_q_path = q_path + q_edge
+
+			if neighbor not in min_q_path or new_q_path < min_q_path[neighbor]:
+				min_q_path[neighbor] = new_q_path
+				heapq.heappush(pq, (new_q_path, neighbor))
+
+	# Return only computed paths for `new_features`
+	return {f: min_q_path[f] for f in new_features}
+
+def prune_graph(Q, target_features, qpath_max, fdr_local, max_radius, custom_nbhd=None, feature_names=None):
+	"""
+	Prunes the estimated graph by enforcing local FDR and pathwise q-value constraints.
+
+	This function takes a dictionary of edge-level q-values and prunes it to retain only edges that:
+		(1) satisfy local false discovery rate (FDR) thresholds at each radius, and
+		(2) lie on a path from a target feature whose cumulative q-value does not exceed qpath_max.
+
+	Inputs
+	----------
+	Q : dict
+		Dictionary of edge-level q-values. Keys are (i,j) tuples and values are q-values.
+	target_features : int or list of int
+		Indices of target features around which the local graph is built.
+	qpath_max : float
+		Maximum allowed sum of q-values along any path from a target to another feature.
+	fdr_local : list of float
+		List of local FDR thresholds for each radius (length must equal max_radius).
+	max_radius : int
+		Maximum radius for local graph expansion.
+	custom_nbhd : dict, optional
+		Dictionary specifying custom FDR thresholds for specific features or substrings (default: None).
+	feature_names : list of str, optional
+		List of feature names (required if custom_nbhd is not None).
+
+	Outputs
+	-------
+	Q_pruned : dict
+		Dictionary of pruned edges (i,j) with their corresponding q-values.
+	"""
+
+	Q_pruned = {}
+
+	if isinstance(target_features, int):
+		target_features = [target_features]
+
+	cumulative_q = {i: qpath_max + 1 for i in range(max(Q.keys(), key=lambda x: x[1])[1] + 1)}
+	for feature in target_features:
+		cumulative_q[feature] = 0
+
+	current_set = set(target_features)
+	radius = 0
+
+	while current_set and radius < max_radius:
+		next_set = set()
+
+		for current in current_set:
+			cutoff = fdr_local[radius]
+			# Current custom neighborhood
+			customize = False
+			if custom_nbhd is not None:
+				if feature_names is None:
+					raise ValueError('Feature names must be provided if custom_nbhd is not None.')
+				current_feature_name = feature_names[current]
+				if current_feature_name in custom_nbhd:
+					current_custom_nbhd = custom_nbhd[current_feature_name]
+					current_custom_nbhd.setdefault('nbhd_fdr', cutoff)
+					customize = True
+			for (i,j), q in Q.items():
+				# Only proceed if i is the index of the current feature
+				if i != current:
+					continue
+
+				current_cutoff = cutoff
+
+				# Apply custom FDR threshold based on matched feature name substrings
+				if customize:
+					current_cutoff = current_custom_nbhd['nbhd_fdr']
+					for string, custom_fdr in custom_nbhd[current_feature_name].items():
+						if string != 'nbhd_fdr' and string in feature_names[j]:
+							current_cutoff = custom_fdr
+							break
+
+				if j in current_set and radius > 0:
+					if q > current_cutoff:
+						continue
+					elif (j, current) in Q_pruned:
+						Q_pruned[(current, j)] = min(q, Q_pruned[(j,current)])
+					else:
+						Q_pruned[(current, j)] = q
+				elif q > current_cutoff:
+					continue
+				else:
+					new_cumulative_q = cumulative_q[current] + q
+					if new_cumulative_q <= qpath_max:
+						if (j, current) in Q_pruned:
+							Q_pruned[(current, j)] = min(q, Q_pruned[(j,current)])
+						else:
+							Q_pruned[(current, j)] = q
+						if new_cumulative_q < cumulative_q[j]:
+							cumulative_q[j] = new_cumulative_q
+							next_set.add(j)
+
+		current_set = next_set
+		radius += 1
+
+	return Q_pruned

localgraph-0.1.0/localgraph/pfs/main.py

@@ -0,0 +1,133 @@
+# Pathwise feature selection (PFS)
+
+from ipss import ipss
+import numpy as np
+
+from .helpers import lightest_paths, prune_graph
+
+def pfs(X, target_features, qpath_max, max_radius=3, fdr_local=None, custom_nbhd=None, feature_names=None, 
+	criterion='min', selector='gb', ipss_args=None, verbose=False):
+	"""
+	Inputs:
+		Required
+		----------------
+		X: n-by-p data matrix (n = number of samples, p = number of features)
+		target_features: list of indices of the target features
+		qpath_max: maximum allowed sum of q-values along paths
+
+		Optional
+		----------------
+		max_radius: maximum radius of the estimated local graph
+		fdr_local: neighborhood FDR threshold at each radius (list of length max_radius)
+		custom_nbhd: dictionary of custom neighborhood FDR thresholds for user-specified features
+		feature_names: names of the features, used if custom_nbhd is provided
+		criterion:
+		selector: base method for computing q-values
+		ipss_args: additional arguments passed to the IPSS function
+		verbose: whether to print progress during selection
+
+	Outputs:
+		A dictionary containing:
+			- 'Q': dict mapping edge tuples to q-values
+			- 'A': adjusted sparse adjacency matrix (dict of dicts or matrix)
+	"""
+
+	if fdr_local is None:
+		fdr_local = [qpath_max] * max_radius
+
+	if ipss_args is None:
+		ipss_args = {}
+	ipss_args['selector'] = selector
+
+	if isinstance(target_features, int):
+		target_features = [target_features]
+
+	current_features = set(target_features)
+	all_visited = set(target_features)
+	radius = 0
+	Q = {}
+
+	while current_features and radius < max_radius:
+
+		if verbose:
+			n_current = len(current_features)
+			ipss_iteration = 1
+			print(f'current features: {current_features} (radius = {radius + 1}/{max_radius})')
+
+		cutoff = fdr_local[radius]
+		fdr_same_layer = cutoff if radius == 0 else fdr_local[radius - 1]
+
+		new_features = set()
+
+		for current in current_features:
+
+			if verbose:
+				print(f' - iteration {ipss_iteration}/{len(current_features)}')
+				ipss_iteration += 1
+
+			# current custom neighborhood
+			customize = False
+			if custom_nbhd is not None:
+				if feature_names is None:
+					raise ValueError('Feature names must be provided if custom_nbhd is not None.')
+				current_feature_name = feature_names[current]
+				if current_feature_name in custom_nbhd:
+					current_custom_nbhd = custom_nbhd[current_feature_name]
+					current_custom_nbhd.setdefault('nbhd_fdr', cutoff)
+					customize = True
+
+			# compute q-values
+			X_minus_current = np.delete(X, current, axis=1)
+			result = ipss(X_minus_current, X[:,current], **ipss_args)
+
+			efp_scores = result['efp_scores']
+			q_values = result['q_values']
+
+			for feature_idx, q_value in q_values.items():
+				# reindex feature to account for deletion of current feature in X_minus_current
+				feature_idx = feature_idx if feature_idx < current else feature_idx + 1
+
+				current_cutoff = cutoff
+				# check for custom fdr cutoffs
+				if customize:
+					current_cutoff = current_custom_nbhd['nbhd_fdr']
+					for string, custom_fdr in custom_nbhd[current_feature_name].items():
+						if string != 'nbhd_fdr' and string in feature_names[feature_idx]:
+							current_cutoff = custom_fdr
+							break
+
+				# update if feature is entirely new
+				if q_value <= current_cutoff and feature_idx not in all_visited:
+					Q[(current, feature_idx)] = Q[(feature_idx, current)] = q_value
+					new_features.add(feature_idx)
+
+				# update if feature in same layer as current
+				elif feature_idx in current_features:
+					if q_value <= fdr_same_layer:
+						if (feature_idx, current) not in Q:
+							Q[(current, feature_idx)] = Q[(feature_idx, current)] = q_value
+						elif Q[(feature_idx, current)] > q_value:
+							Q[(current, feature_idx)] = Q[(feature_idx, current)] = q_value						
+
+				# update edge with minimum q-value if criterion is 'min'
+				elif q_value <= current_cutoff and criterion == 'min':
+					if (feature_idx, current) not in Q:
+						Q[(current, feature_idx)] = Q[(feature_idx, current)] = q_value
+					elif Q[(feature_idx, current)] > q_value:
+						Q[(current, feature_idx)] = Q[(feature_idx, current)] = q_value
+
+		q_paths = lightest_paths(Q, target_features, new_features)
+		new_features = {idx for idx, q_value_sum in q_paths.items() if q_value_sum <= qpath_max}
+
+		current_features = new_features
+		all_visited.update(new_features)
+		radius += 1
+
+	# Compute final Q by applying pathwise threshold qpath_max
+	Q = prune_graph(Q, target_features, qpath_max, fdr_local, max_radius)
+
+	return Q
+
+
+
+

localgraph-0.1.0/localgraph/plotting/helpers.py

@@ -0,0 +1,58 @@
+# Helper functions for plot_graph.py
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+
+def assign_node_colors(G, target_features, n_layers, colors=None):
+	if colors is not None:
+		if isinstance(colors, dict):
+			return [colors.get(node, 'gray') for node in G.nodes()]
+		elif isinstance(colors, (list, np.ndarray)):
+			return [colors[node] if node < len(colors) else 'gray' for node in G.nodes()]
+		else:
+			raise ValueError("`colors` must be a dict, list, or None.")
+
+	if isinstance(target_features, int):
+		target_features = [target_features]
+
+	# Default: color by distance from target_features
+	color_map = {}
+	standout_color = 'yellow'
+	default_colors = generate_colors(n_layers)
+	shortest_paths_from_roots = {
+		r: nx.single_source_shortest_path_length(G,r) for r in target_features
+	}
+
+	for node in G.nodes():
+		if node in target_features:
+			color_map[node] = standout_color
+		else:
+			min_dist = min(
+				paths.get(node, float('inf')) for paths in shortest_paths_from_roots.values()
+			)
+			if min_dist < float('inf'):
+				color_map[node] = default_colors[min(min_dist - 1, len(default_colors) - 1)]
+			else:
+				color_map[node] = 'skyblue'
+
+	return [color_map[node] for node in G.nodes()]
+
+def generate_colors(n):
+	"""Generate a yellow-green-blue gradient from 'gist_rainbow', skipping red/magenta."""
+	colormap = plt.cm.get_cmap('gist_rainbow')
+	colors = []
+	for i in range(n):
+		t = 0 if n == 1 else i / (n - 1)  # Normalize to [0,1]
+		# Remap t to skip red and magenta sections (keep yellow-green-blue)
+		t_new = 0.4 + 0.4 * t  # Maps t from [0.4, 0.8] in colormap
+		# Get color from colormap
+		color = np.array(colormap(t_new)[:3])
+		# Reduce saturation as nodes get farther
+		fade_factor = 0.65 - 0.55 * t  # High at t=0 (closer), fades at t=1 (farther)
+		color = color * fade_factor + (1 - fade_factor)  # Desaturate progressively
+		# Convert to hex
+		colors.append('#%02x%02x%02x' % tuple(int(255 * c) for c in color))
+	return colors
+
+

localgraph-0.1.0/localgraph/plotting/plot_graph.py

@@ -0,0 +1,236 @@
+# Plot a local subgraph around target features, with flexible graph input
+
+import copy
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+
+from .helpers import assign_node_colors, generate_colors
+
+def plot_graph(
+	graph, target_features, radius, feature_names=None, true_graph=None,
+	graph_layout='kk', node_size=1500, font_size=10, edge_font_size=None, edge_digits=2, edge_widths=1, colors=None,
+	show_weights=True, include_outer_edges=False, figsize=(16,8), ax=None, pos=None,
+	save_fig=False, save_graph=False, graph_name=None, dpi=300
+):
+	"""
+	Inputs:
+		Required
+		----------------
+		graph: input graph, either as a dictionary of edge weights, a numpy array (adjacency matrix), or NetworkX graph
+		target_features: list of indices of the target features
+		radius: maximum radius of the local graph
+
+		Optional
+		----------------
+		# Labeling
+		feature_names: list of feature names for labeling nodes
+		true_graph: ground truth adjacency matrix, if known (used to color true/false edges black/red)
+		
+		# Visualization
+		graph_layout: layout algorithm (several options from NetworkX; default is kamada-kawai)
+		node_size: size of nodes in the plot
+		font_size: size of node labels
+		edge_font_size: size of edge weight labels
+		edge_digits: number of digits to round edge weights
+		edge_widths: width of edges (float for uniform width; 'q_value' to scale by q-values)
+		colors: list of custom colors for nodes (default: color by distance from target nodes)
+		show_weights: whether to display edge weights
+		include_outer_edges: whether to include edges between outermost nodes
+		figsize: size of the figure (width, height)
+		ax: matplotlib axis object (for use in subplots or custom figures)
+		pos: dictionary of node positions (overrides automatic layout)
+
+		# Saving
+		save_fig: whether to save the figure as a PNG
+		save_graph: whether to save the graph as a GraphML file
+		graph_name: name of the output file if saving
+		dpi: resolution of the saved figure
+
+	Outputs:
+		Returns a dictionary containing:
+			- 'feature_radius_list': list of (feature_name, radius) pairs for each node in the plotted subgraph
+			- 'graph': NetworkX graph object for the plotted subgraph
+			- 'positions': dictionary mapping nodes to their 2D coordinates in the plot
+	"""
+
+	if edge_font_size is None:
+		edge_font_size = font_size
+
+	# Create networkx graph G from graph
+	if isinstance(graph, nx.Graph):
+		G = graph.copy()
+	elif isinstance(graph, dict):
+		G = nx.Graph()
+		for (i,j), q in graph.items():
+			G.add_edge(i, j, weight=q)
+	elif isinstance(graph, np.ndarray):
+		G = nx.Graph()
+		for i in range(graph.shape[0]):
+			for j in range(graph.shape[1]):
+				weight = graph[i,j]
+				if weight != 0:
+					G.add_edge(i, j, weight=weight)
+	else:
+		raise TypeError("Unsupported graph input type. Must be a NetworkX graph, dict, or numpy array.")
+
+	# Find nodes within the specified radius
+	reachable_nodes = set()
+	node_distances = {}
+
+	if isinstance(target_features, int):
+		target_features = [target_features]
+
+	for root in target_features:
+		if G.has_node(root):
+			path_lengths = nx.single_source_shortest_path_length(G, root, cutoff=radius)
+			reachable_nodes.update(path_lengths.keys())
+			for node, dist in path_lengths.items():
+				if node not in node_distances or dist < node_distances[node]:
+					node_distances[node] = dist
+
+	# Remove edges between outermost nodes if requested
+	if not include_outer_edges:
+		outer_nodes = {node for node, dist in node_distances.items() if dist == radius}
+		G.remove_edges_from([(u, v) for u, v in G.edges() if u in outer_nodes and v in outer_nodes])
+
+	# Create subgraph
+	G = G.subgraph(reachable_nodes).copy()
+
+	if G.number_of_nodes() == 0:
+		print("Empty graph: All root nodes are isolated.")
+		return
+
+	# Handle plotting
+	own_figure = False
+	if ax is None:
+		fig, ax = plt.subplots(figsize=figsize)
+		own_figure = True
+
+	# Graph layout selection
+	if pos is not None:
+		pos = {node: (float(x), float(y)) for node, (x, y) in pos.items()}
+	else:
+		if graph_layout == 'circular':
+			pos = nx.circular_layout(G)
+		elif graph_layout in ['kk', 'kamada_kawai']:
+			pos = nx.kamada_kawai_layout(G, weight=False)
+		elif graph_layout == 'multipartite':
+			pos = nx.multipartite_layout(G)
+		elif graph_layout == 'planar':
+			pos = nx.planar_layout(G)
+		elif graph_layout == 'spectral':
+			pos = nx.spectral_layout(G)
+		elif graph_layout == 'spring':
+			pos = nx.spring_layout(G, weight=None)
+		else:
+			raise ValueError(f"Unsupported graph format: {graph_layout}")
+
+	# Assign node colors
+	node_color = assign_node_colors(G, target_features, radius, colors=colors)
+
+	# Get weights
+	weights = [G[u][v]['weight'] for u, v in G.edges()]
+	max_weight = max(weights) if weights else 1
+
+	# Assign edge colors based on whether they exist in true_graph
+	if true_graph is not None:
+		true_edges = set()
+		for i in range(true_graph.shape[0]):
+			for j in range(true_graph.shape[1]):
+				if true_graph[i,j] != 0:
+					true_edges.add((i,j))
+					true_edges.add((j,i))
+		edge_colors = ['black' if (u,v) in true_edges else 'red' for u, v in G.edges()]
+	else:
+		edge_colors = ['black' for u, v, in G.edges()]
+
+	# Node sizes
+	node_sizes = [node_size * 1.5 if node in target_features else node_size for node in G.nodes()]
+
+	# Edge widths
+	edge_widths_clean = str(edge_widths).replace('-', '_').lower()
+	if edge_widths_clean in ['by_q_value', 'q_value']:
+		q_vals = [G[u][v]['weight'] for u, v in G.edges()]
+		q_min, q_max = min(q_vals), max(q_vals)
+		if q_max == q_min:
+			edge_widths = 1
+		else:
+			def rescale(q):
+				t = (q - q_min) / (q_max - q_min)
+				return max(5 * (1 - t), 1)
+			edge_widths = [rescale(G[u][v]['weight']) for u, v in G.edges()]
+
+	# Draw nodes and edges
+	nx.draw(G, pos, ax=ax, with_labels=False, node_color=node_color, node_size=node_sizes, edge_color=edge_colors,
+			edgecolors='black', linewidths=1, alpha=1, width=edge_widths)
+
+	if show_weights:
+		edge_labels = {(u, v): f'{G[u][v]["weight"]:.{edge_digits}f}' for u, v in G.edges()}
+		text_items = nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=edge_font_size, ax=ax)
+		# Manually update colors
+		for (u,v), text in text_items.items():
+			if true_graph is not None:
+				edge_color = 'black' if (u,v) in true_edges else 'red'
+			else:
+				edge_color = 'black'
+			text.set_color(edge_color)  # Change label color dynamically
+
+	# Add custom node labels
+	if feature_names is None:
+		node_labels = {node: f'$X_{{{node + 1}}}$' for node in reachable_nodes}
+	else:
+		node_labels = {node: feature_names[node] for node in reachable_nodes}
+
+	# Custom node labels with individual font sizes
+	for node, (x,y) in pos.items():
+		label = node_labels[node]
+		node_font_size = int(font_size * 1.25) if node in target_features else font_size
+		ax.text(x, y, label, fontsize=node_font_size, ha='center', va='center', 
+				bbox=dict(facecolor='white', edgecolor='none', alpha=0))  # Background for readability
+
+	# Collect (feature_name, radius) pairs
+	assigned_nodes = set()
+	radius_groups = {}
+
+	for r in range(max(node_distances.values()) + 1):
+		nodes_at_r = {node for node, dist in node_distances.items() if dist == r}
+		new_nodes = nodes_at_r - assigned_nodes
+		if new_nodes:
+			radius_groups[r] = new_nodes
+			assigned_nodes.update(new_nodes)
+
+	feature_radius_list = []
+	for r in sorted(radius_groups):
+		for node in sorted(radius_groups[r]):
+			name = node_labels[node]
+			feature_radius_list.append((name, r))
+
+	if own_figure:
+		plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
+		if save_fig:
+			if graph_name is None:
+				print(f'Warning: graph_name not provided. Setting graph_name = my_graph')
+				graph_name = 'my_graph'
+			plt.savefig(f'{graph_name}.png', dpi=dpi)
+		plt.show()
+
+	if save_graph:
+		if graph_name is None:
+			print(f'Warning: graph_name not provided. Setting graph_name = my_graph')
+			graph_name = 'my_graph'
+		for node, (x, y) in pos.items():
+			G.nodes[node]['x'] = float(x)
+			G.nodes[node]['y'] = float(y)
+		nx.write_graphml(G, f'{graph_name}.graphml')
+
+	result = {'feature_radius_list':feature_radius_list, 'graph':G, 'positions':pos}
+	if own_figure:
+		result['figure'] = fig
+
+	return result
+
+
+
+

localgraph-0.1.0/localgraph.egg-info/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: localgraph
+Version: 0.1.0
+Summary: Local graph estimation with pathwise feature selection
+Author: Omar Melikechi
+Author-email: omar.melikechi@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ipss>=1.1.1
+Requires-Dist: matplotlib>=3.0.0
+Requires-Dist: networkx>=2.0
+Requires-Dist: numpy>=1.16.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Local graph estimation with pathwise feature selection
+
+> **Local graph estimation** is a framework for discovering local graph/network structure around specific variables of interest. **Pathwise feature selection (PFS)** is an algorithm for performing local graph estimation with pathwise false discovery control.
+
+## Associated paper
+
+- **Local graph estimation: Interpretable network discovery for complex data**  
+	In preparation
+
+## Installation
+```
+pip install localgraph
+```
+
+## Usage
+```python
+from localgraph import pfs, plot_graph
+
+# Load n-by-p data matrix X (n samples, p features)
+
+# Specify the target features (list of indices)
+target_features = [0, 1]
+
+# Specify the pathwise q-value threshold
+qpath_max = 0.2
+
+# Optional: specify the maximum radius of the local graph (default is 3)
+max_radius = 3
+
+# Optional: specify the neighborhood FDR thresholds for nodes in each radius
+fdr_local = [0.2, 0.1, 0.1]
+
+# Run PFS
+Q = pfs(X, target_features, qpath_max=qpath_max, max_radius=max_radius, fdr_local=fdr_local)
+
+# Plot the estimated subgraph
+plot_graph(graph=Q, target_features=target_features, radius=max_radius)
+```
+
+### Outputs
+- `Q`: Dictionary mapping edges `(i,j)` to q-values. Edges are undirected, so `(i,j)` and `(j,i)` are included.
+
+### What PFS does
+- Expands the local graph outward, layer by layer, starting from target variables.
+- Performs neighborhood selection with FDR control using [**integrated path stability selection**](https://github.com/omelikechi/ipss).
+- Controls pathwise false discoveries by summing q-values along candidate paths.
+
+## Full list of `pfs` arguments
+
+### Required arguments:
+- `X`: n-by-p data matrix (NumPy array). Each column is a feature/variable.
+- `target_features`: Feature index or list of indices to center the graph around.
+- `qpath_max`: Maximum allowed sum of q-values along any path.
+
+### Optional arguments:
+- `max_radius`: Maximum number of expansion layers around each target (int; default `3`).
+- `fdr_local`: Neighborhood FDR threshold at each radius (list of length `max_radius`; default `[qpath_max]*max_radius`).
+- `custom_nbhd`: Dictionary specifying custom FDR cutoffs for certain features (dict; default `None`).
+- `feature_names`: List of feature names; required if `custom_nbhd` is provided (list of strings).
+- `criterion`: Rule for resolving multiple edges (default `'min'`).
+- `selector`: Feature importance method used by IPSS (str; default `'gb'`). Options:
+	- `'gb'`: Gradient boosting
+	- `'l1'`: L1-regularized regression (lasso)
+	- `'rf'`: Random forest
+	- Custom function (see `ipss_args`)
+- `ipss_args`: Dictionary of arguments to pass to `ipss` (dict; default `None`)
+- `verbose`: Whether to print progress during selection (bool; default `False`)
+
+## Graph plotting
+
+Use `plot_graph` to visualize a local graph up to the specified `radius` around one or more target features.
+
+```python
+from localgraph import plot_graph
+
+# Plot local graph around target_features using output Q from pfs
+plot_graph(graph=Q, target_features=target_features, radius=3)
+```
+
+### Features and customization
+`plot_graph` visualizes a local graph of a user-specified radius around one or more target features. It supports:
+- Flexible input formats: edge dictionary, adjacency matrix, or NetworkX graph
+- Automatic subgraph extraction around the targets
+- Node coloring by distance from the target(s) (default), or user-specified colors (e.g., by variable type)
+- Several layout algorithms (`'kamada_kawai'`, `'spring'`, `'circular'`, etc.)
+- Customizable node size, font sizes, and edge thickness
+- Optional display of q-values; edge widths can reflect q-value strength (`edge_widths='q_value'`)
+- False positives shown in red if the true graph is provided
+- Integration with custom plots via `ax` or `pos`
+- Optional saving of figures (`save_fig`) and graphs (`save_graph`)
+
+For a full list of arguments, see the [`plot_graph`](./localgraph/plotting/plot_graph.py) docstring.
+
+### Returns
+The function returns a dictionary containing:
+- `feature_radius_list`: List of `(feature name, radius)` pairs for all nodes in the graph.
+- `graph`: The NetworkX subgraph used for plotting.
+- `positions`: Dictionary of node coordinates.
+- `figure`: The matplotlib figure object (only if the function creates the figure).
+
+### Further customization
+
+To manually adjust node positions for publication-quality figures, you can export graphs to [**Gephi**](https://gephi.org/), edit them interactively, and re-import the updated layout into Python. See: [gephi_instructions.md](./gephi_instructions.md) for a full walkthrough.
+
+## Examples
+
+The `examples/` folder contains scripts that demonstrate end-to-end usage:
+
+- `simple_example.py`: Simulate data, run PFS, and visualize the result.
+
+## Evaluation tools
+
+The `evaluation/` folder contains helper functions for measuring subgraph recovery in simulation settings.
+
+- The `eval.py` script contains two functions:
+	- `subgraph_within_radius`: Extract true subgraph around a target node (useful for identifying subgraphs within full graphs)
+	- `tp_and_fp`: Count true and false positives compared to ground truth
+
+These are useful for benchmarking PFS and other graph estimation methods when the true graph is known.
+
+
+
+
+
+
+
+
+
+

localgraph-0.1.0/localgraph.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+setup.py
+localgraph/__init__.py
+localgraph.egg-info/PKG-INFO
+localgraph.egg-info/SOURCES.txt
+localgraph.egg-info/dependency_links.txt
+localgraph.egg-info/requires.txt
+localgraph.egg-info/top_level.txt
+localgraph/evaluation/__init__.py
+localgraph/evaluation/eval.py
+localgraph/examples/__init__.py
+localgraph/examples/simple_example.py
+localgraph/pfs/__init__.py
+localgraph/pfs/helpers.py
+localgraph/pfs/main.py
+localgraph/plotting/__init__.py
+localgraph/plotting/helpers.py
+localgraph/plotting/plot_graph.py

localgraph-0.1.0/localgraph.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

localgraph-0.1.0/localgraph.egg-info/requires.txt

@@ -0,0 +1,4 @@
+ipss>=1.1.1
+matplotlib>=3.0.0
+networkx>=2.0
+numpy>=1.16.0

localgraph-0.1.0/localgraph.egg-info/top_level.txt

@@ -0,0 +1 @@
+localgraph

localgraph-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

localgraph-0.1.0/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+setup(
+	name='localgraph',
+	version='0.1.0',
+	author='Omar Melikechi',
+	author_email='omar.melikechi@gmail.com',
+	description='Local graph estimation with pathwise feature selection',
+	long_description=open('README.md').read(),
+	long_description_content_type='text/markdown',
+	packages=find_packages(include=["localgraph", "localgraph.*"]),
+	install_requires=[
+	'ipss>=1.1.1',
+	'matplotlib>=3.0.0',
+	'networkx>=2.0',
+	'numpy>=1.16.0',
+	],
+	python_requires='>=3.6',
+	include_package_data=True,
+	classifiers=[
+		'Programming Language :: Python :: 3',
+		'License :: OSI Approved :: MIT License',
+		'Operating System :: OS Independent',
+	],
+)