Spaces:
Sleeping
Sleeping
Download src/modules/artifacts.py from Sierpinksi-Project/NGF_on_Fractale: direct link, hf CLI and curl.
- Browser
- Download file 3.76 kB
-
https://huggingface.co/spaces/Sierpinksi-Project/NGF_on_Fractale/resolve/main/src/modules/artifacts.py
- Command line
-
hf download hf://spaces/Sierpinksi-Project/NGF_on_Fractale/src/modules/artifacts.py
-
curl -L -o artifacts.py https://huggingface.co/spaces/Sierpinksi-Project/NGF_on_Fractale/resolve/main/src/modules/artifacts.py
3.76 kB
| from __future__ import annotations | |
| import io | |
| import zipfile | |
| from typing import Dict, Tuple | |
| import networkx as nx | |
| import numpy as np | |
| import pandas as pd | |
| import scipy.sparse as sp | |
| def _graph_to_edge_list(G: nx.Graph, use_real_pos: bool = False) -> Tuple[pd.DataFrame, pd.DataFrame]: | |
| nodes_rows = [] | |
| edges_rows = [] | |
| for n, data in G.nodes(data=True): | |
| if use_real_pos and "pos_real" in data: | |
| p = data["pos_real"] | |
| else: | |
| p = data.get("pos") | |
| if p is None: | |
| x = y = z = float("nan") | |
| else: | |
| x, y, z = float(p[0]), float(p[1]), float(p[2]) | |
| nodes_rows.append({"node_id": n, "x": x, "y": y, "z": z}) | |
| for u, v, edata in G.edges(data=True): | |
| edges_rows.append( | |
| { | |
| "u": u, | |
| "v": v, | |
| "weight": float(edata.get("weight", 1.0)), | |
| "energy": float(edata.get("energy", 0.0)), | |
| } | |
| ) | |
| df_nodes = pd.DataFrame(nodes_rows) | |
| df_edges = pd.DataFrame(edges_rows) | |
| return df_nodes, df_edges | |
| def make_artifacts_zip(context: Dict) -> bytes: | |
| """ | |
| Sammle wichtige Artefakte eines Runs in einem ZIP. | |
| """ | |
| G_ideal = context["G_ideal"] | |
| G_real = context["G_real"] | |
| pos_real = context["pos_real"] | |
| Q = context["Q"] | |
| node_order = context["node_order"] | |
| bath_info = context["bath"] | |
| f_potential = context["potential"] | |
| edge_energies = context["edge_energies"] | |
| address_df = context["address_df"] | |
| # REAL-Positionen im Graph speichern | |
| for nid, p in pos_real.items(): | |
| G_real.nodes[nid]["pos_real"] = p | |
| ideal_nodes_df, ideal_edges_df = _graph_to_edge_list(G_ideal, use_real_pos=False) | |
| real_nodes_df, real_edges_df = _graph_to_edge_list(G_real, use_real_pos=True) | |
| boundary_values = bath_info["boundary_values"] | |
| boundary_order = bath_info["boundary_order"] | |
| C = bath_info["C"] | |
| df_bath = pd.DataFrame( | |
| { | |
| "boundary_node": boundary_order, | |
| "value": [float(boundary_values[n]) for n in boundary_order], | |
| } | |
| ) | |
| df_potential = pd.DataFrame( | |
| { | |
| "node_id": list(f_potential.keys()), | |
| "potential": [float(v) for v in f_potential.values()], | |
| } | |
| ) | |
| edge_rows = [] | |
| for (u, v), E in edge_energies.items(): | |
| edge_rows.append({"u": u, "v": v, "energy": float(E)}) | |
| df_edge_energy = pd.DataFrame(edge_rows) | |
| df_Q_nodes = pd.DataFrame({"index": list(range(len(node_order))), "node_id": node_order}) | |
| buf = io.BytesIO() | |
| with zipfile.ZipFile(buf, mode="w", compression=zipfile.ZIP_DEFLATED) as zf: | |
| def add_df(name: str, df: pd.DataFrame): | |
| inner = io.StringIO() | |
| df.to_csv(inner, index=False) | |
| zf.writestr(name, inner.getvalue()) | |
| add_df("ideal_nodes.csv", ideal_nodes_df) | |
| add_df("ideal_edges.csv", ideal_edges_df) | |
| add_df("real_nodes.csv", real_nodes_df) | |
| add_df("real_edges.csv", real_edges_df) | |
| add_df("bath_boundary_values.csv", df_bath) | |
| add_df("bath_covariance_C.csv", pd.DataFrame(C)) | |
| add_df("potential_f.csv", df_potential) | |
| add_df("edge_energies.csv", df_edge_energy) | |
| add_df("Q_node_order.csv", df_Q_nodes) | |
| add_df("cell_address_tree.csv", address_df) | |
| if sp.issparse(Q): | |
| zf.writestr("Q_sparse_shape.txt", f"{Q.shape[0]} {Q.shape[1]}") | |
| coo = Q.tocoo() | |
| df_Q = pd.DataFrame( | |
| { | |
| "row": coo.row.astype(int), | |
| "col": coo.col.astype(int), | |
| "data": coo.data.astype(float), | |
| } | |
| ) | |
| add_df("Q_sparse_entries.csv", df_Q) | |
| return buf.getvalue() | |