深入理解rpy2中的NumPy矩阵与R矩阵转换的最佳实践

import rpy2.robjects as robjects
from rpy2.robjects import numpy2ri
from rpy2.robjects.conversion import localconverter
import numpy as np

# 创建一个NumPy数组
python_array = np.array([[1, 2], [3, 4]], dtype=np.int32)
print(f"Python数组类型: {type(python_array)}")
print(f"Python数组内容:\n{python_array}")

# 使用局部转换器将NumPy数组转换为R矩阵
with localconverter(robjects.default_converter + numpy2ri.converter):
    # 此时，在with块内部，NumPy数组会被自动转换为R对象
    # 如果直接将python_array赋值给R变量，它将转换为R矩阵
    r_matrix_direct = robjects.conversion.py2rpy(python_array)
    print(f"\n直接转换后的R对象类型 (使用py2rpy): {type(r_matrix_direct)}")
    print(f"直接转换后的R对象内容:\n{r_matrix_direct}")

    # 也可以结合robjects.r.matrix来创建R矩阵
    # numpy2ri会先将python_array扁平化为R向量，再由R matrix函数重塑
    r_matrix_via_r_matrix = robjects.r.matrix(python_array, nrow=2, ncol=2)
    print(f"\n通过robjects.r.matrix转换后的R对象类型: {type(r_matrix_via_r_matrix)}")
    print(f"通过robjects.r.matrix转换后的R对象内容:\n{r_matrix_via_r_matrix}")

# 退出with块后，全局转换规则恢复原样，NumPy数组不再自动转换
# 尝试在外部转换会失败或得到不同的结果，除非手动指定转换
# 例如，如果没有numpy2ri，robjects.r.matrix可能会报错或将数组视为单个元素

import rpy2.robjects as robjects
from rpy2.robjects import numpy2ri
from rpy2.robjects.conversion import localconverter
from rpy2.robjects.packages import importr
import numpy as np
import networkx as nx

# 导入R包，例如igraph，这里只是为了示例graphNEL类型
# graph = importr('graph') # 假设需要graphNEL类型

def sample_graphs_improved(mpgraph, n_graphs=10, equal_weights=False):
    graphs = []
    if nx.is_directed_acyclic_graph(nx.DiGraph(mpgraph)):
        graphs.append((mpgraph.copy(), n_graphs))
    else:
        n_vars = mpgraph.shape[0]
        addBgKnowledge = robjects.r['addBgKnowledge'] # 假设这是R中的一个函数

        # 将转换器定义在循环外部，并使用localconverter包裹整个需要R交互的逻辑
        with localconverter(robjects.default_converter + numpy2ri.converter):
            for _ in range(n_graphs):
                graph = mpgraph.copy()
                undirected_u, undirected_v = np.nonzero(np.triu(graph == graph.T) & (graph == 1))

                while len(undirected_u) > 0:
                    selected_edge_idx = np.random.randint(0, len(undirected_u))
                    u, v = undirected_u[selected_edge_idx], undirected_v[selected_edge_idx]
                    if np.random.rand() < 0.5:
                        u, v = v, u

                    # cpgraph已经是NumPy数组，在localconverter作用下，
                    # 传递给robjects.r.matrix时会自动转换为R向量
                    # 或者，如果R函数直接接受R矩阵，则直接传递cpgraph
                    cpgraph_r_matrix = robjects.r.matrix(graph, nrow=n_vars, ncol=n_vars)

                    # 确保cpgraph_r_matrix是正确的R矩阵类型
                    print(f"转换后的R矩阵类型: {type(cpgraph_r_matrix)}")

                    # 设置行名和列名
                    cpgraph_r_matrix.rownames = robjects.StrVector([str(i) for i in range(n_vars)])
                    cpgraph_r_matrix.colnames = robjects.StrVector([str(i) for i in range(n_vars)])

                    # r_as函数也受益于localconverter
                    # 确保'graphNEL'类型存在且可以被转换
                    # r_as = robjects.r['as'] # 假设as是一个R函数
                    # cpgraph_graphNEL = r_as(cpgraph_r_matrix, 'graphNEL')

                    # 假设addBgKnowledge直接接受R矩阵或graphNEL对象
                    # graph = robjects.conversion.rpy2py(addBgKnowledge(cpgraph_graphNEL, x=[str(u)], y=[str(v)]))
                    # 这里为了简化，假设addBgKnowledge直接返回R矩阵，然后转回NumPy
                    graph_r_result = addBgKnowledge(cpgraph_r_matrix, x=[str(u)], y=[str(v)])
                    graph = robjects.conversion.rpy2py(graph_r_result).astype(int)


                    undirected_u, undirected_v = np.nonzero(np.triu(graph == graph.T) & (graph == 1))

                found = False
                for idx, (comp_graph, weight) in enumerate(graphs):
                    if (comp_graph == graph).all():
                        graphs[idx] = (graph, weight + 1)
                        found = True
                        break
                if not found:
                    graphs.append((graph, 1))

    if equal_weights:
        graphs = [(graph, 1 / len(graphs)) for graph, _ in graphs]
    else:
        graphs = [(graph, w / n_graphs) for graph, w in graphs]
    return graphs

# 假设mpgraph是一个NumPy数组
# mpgraph_example = np.array([[0, 1, 0], [0, 0, 1], [0, 0, 0]], dtype=np.int32)
# result_graphs = sample_graphs_improved(mpgraph_example)
# print(result_graphs)