idopNetwork程序包解析

合集 - 复杂网络构建(1)

1.idopNetwork程序包解析2023-12-10

收起

data_cleaning源代码

#' @title remove observation with too many 0 values
#' @param data dataframe of imported dataset, must have first column as ID
#' @param x scales indicate how many 0 to remove
#' @return a dataframe without too many 0 observations
#' @examples
#' data_cleaning(matrix(c(c(0,1,1,0,0,1,1), c(2,1,0,3,5,2,2), c(1,1,3,2,4,5,1)), 3, 7), 2)
#' @importFrom stats aggregate
#' @export
data_cleaning <- function(data, x = round(ncol(data)*0.3)){
  data = aggregate(data[,2:ncol(data)], by=list(data[,1]), FUN = 'sum')
  rownames(data) = data[,1]
  data = data[,-1]
  tmp = apply(data, 1, function(c) which( as.numeric(c) != 0) )
  keep_no = which(sapply(tmp, length) >= x)
  data2 = data[keep_no,]
  return(data2)
}

这段R语言代码是一个自定义函数，名为 data_cleaning，用于从数据集中移除包含过多0值的观测（行）。下面是对这段代码的中文解释：

• @title remove observation with too many 0 values：该函数的标题，目的是移除包含过多0值的观测。
• @param data：参数 data，代表导入的数据框（dataframe），必须要第一列作为ID（标识）列。
• @param x：参数 x，表示移除观测的阈值，即当一行中0的个数超过这个值时，这一行将被移除。
• @return：返回值，返回一个清理后的数据框，即移除了包含过多0值的观测后的数据。
• @examples：示例用法，展示了如何使用这个函数。
• @importFrom stats aggregate：表示从 stats 包中导入 aggregate 函数。
• @export：表示该函数应该被导出，使得它可以在该R包的命名空间之外被用户访问。

函数定义 data_cleaning <- function(data, x = round(ncol(data)*0.3)){...}：定义了一个名为 data_cleaning 的函数，它接受两个参数：data 是需要清理的数据框，x 是一个用于标识多少个0值会导致一个观测被移除的阈值，默认值为数据框列数的30%（向下取整）。

函数内部操作解释：

1. data = aggregate(data[,2:ncol(data)], by=list(data[,1]), FUN = 'sum')：使用 aggregate 函数按照ID列（第一列）对数据进行分组并求和，忽略了ID列外的第一列。

2. rownames(data) = data[,1]：将分组后的数据框的行名设置为ID列的值。

3. data = data[,-1]：移除数据框的第一列（ID列），因为ID已经被设置为了行名。

4. tmp = apply(data, 1, function(c) which(as.numeric(c) != 0))：使用 apply 函数遍历数据框的每一行，找出每行中非0值的位置，并存储在 tmp 变量中。

5. keep_no = which(sapply(tmp, length) >= x)：通过 sapply 函数计算每行非0值的数量，并找出数量大于等于阈值 x 的行的索引，即这些行会被保留。

6. data2 = data[keep_no,]：根据上一步得到的索引，从数据框中选取符合条件的行，得到清理后的数据框 data2。

7. return(data2)：返回清理后的数据框 data2。

总结：这个函数的目的是从数据集中移除那些包含过多0值的行，仅保留那些非0值数量达到一定阈值的观测。通过调整参数 x，可以控制移除观测的严格程度。

data_match源代码

#' @title match power_equation fit result for bi-variate model
#' @param result1 list object from power_equation fit
#' @param result2 list object from power_equation fit
#' @return a id match list for input dataset
#' @export
data_match <- function(result1, result2){
  matchname = intersect(rownames(result1$original_data),rownames(result2$original_data))

  new_result1 = list(original_data = result1$original_data[matchname,],
                     trans_data = result1$trans_data[matchname,],
                     power_par = result1$power_par[matchname,],
                     power_fit = result1$power_fit[matchname,],
                     Time = result1$Time)

  new_result2 = list(original_data = result2$original_data[matchname,],
                     trans_data = result2$trans_data[matchname,],
                     power_par = result2$power_par[matchname,],
                     power_fit = result2$power_fit[matchname,],
                     Time = result2$Time)
  result = list(dataset1 = new_result1, dataset2 = new_result2)
  return(result)
}

这段R语言代码定义了一个名为data_match的函数，旨在处理和匹配两个双变量模型的功率方程拟合结果。以下是代码的逐行解释：

1. #' @title match power_equation fit result for bi-variate model：
   这一行是一个注释，说明了函数的标题，即“为双变量模型匹配功率方程拟合结果”。

2. #' @param result1 list object from power_equation fit：
   这一行是一个注释，说明函数的第一个参数result1，它是一个列表对象，包含了从power_equation函数拟合得到的结果。

3. #' @param result2 list object from power_equation fit：
   这一行是一个注释，说明函数的第二个参数result2，它同样是一个列表对象，包含了从power_equation函数拟合得到的结果。

4. #' @return a id match list for input dataset：
   这一行是一个注释，说明了函数的返回值，即一个匹配了输入数据集ID的列表。

5. #' @export：
   这一行是一个注释，在R包的命名空间中使用，表示这个函数应当被导出，使得它可以被包的用户调用。

6. data_match <- function(result1, result2){：
   这行代码定义了data_match函数，接受两个参数result1和result2。

7. matchname = intersect(rownames(result1$original_data),rownames(result2$original_data))：
   这条语句计算两个输入列表中original_data数据框的行名的交集，即找出两个结果集中都存在的ID。

8. 以下几行创建了new_result1列表，它包含了与matchname相匹配的result1中的各个组件的子集：

   new_result1 = list(original_data = result1$original_data[matchname,],
trans_data = result1$trans_data[matchname,],
power_par = result1$power_par[matchname,],
power_fit = result1$power_fit[matchname,],
Time = result1$Time)

9. 类似地，创建了new_result2列表，它包含了与matchname相匹配的result2中的各个组件的子集：

   new_result2 = list(original_data = result2$original_data[matchname,],
trans_data = result2$trans_data[matchname,],
power_par = result2$power_par[matchname,],
power_fit = result2$power_fit[matchname,],
Time = result2$Time)

10. result = list(dataset1 = new_result1, dataset2 = new_result2)：
    这条语句将new_result1和new_result2组合为一个新的列表result，其中包含了两个匹配的数据集。

11. return(result)：
    函数返回处理后的匹配列表result。

总的来说，这个函数的目的是将两个由功率方程拟合得到的结果进行匹配，确保两者包含相同的观测点ID，从而可以在后续分析中对它们进行比较和组合。

power_equation源代码

#' @title use power equation parameters to generate y values
#' @param x vector for x values
#' @param power_par matrix contain parameters for power equation
#' @return y values for given power equation parameters
#' @examples
#' power_equation(c(1,2,3,5,7), matrix(c(2,1,1,2),2,2))
#' @export
power_equation <- function(x, power_par){ t(sapply(1:nrow(power_par),
                                                   function(c) power_par[c,1]*x^power_par[c,2] ) )}

这段R语言代码定义了一个名为power_equation的函数，用来根据给定的幂函数参数生成对应的y值。下面是代码的逐行解释：

1. #' @title use power equation parameters to generate y values：
   这一行是一个注释，说明了函数的标题，即“使用幂方程参数生成y值”。

2. #' @param x vector for x values：
   这一行是一个注释，说明函数的第一个参数x，它是一个向量，包含了x的值。

3. #' @param power_par matrix contain parameters for power equation：
   这一行是一个注释，说明函数的第二个参数power_par，它是一个矩阵，包含了幂方程的参数。

4. #' @return y values for given power equation parameters：
   这一行是一个注释，说明了函数的返回值，即基于给定的幂方程参数计算出来的y值。

5. #' @examples：
   这一行是一个注释，引导读者看函数的示例。

6. #' power_equation(c(1,2,3,5,7), matrix(c(2,1,1,2),2,2))：
   这一行是一个示例，展示了如何使用power_equation函数，其中x值为向量c(1,2,3,5,7)，幂方程的参数为2x2矩阵matrix(c(2,1,1,2), 2, 2)。

7. #' @export：
   这一行是一个注释，指示R包的命名空间，表示这个函数应当被导出，使得包的用户可以调用它。

8. power_equation <- function(x, power_par){ ... }：
   这行代码定义了power_equation函数，它接受两个参数x和power_par。

9. t(sapply(1:nrow(power_par), function(c) power_par[c,1]*x^power_par[c,2] ))：
   这是函数的主体部分。它首先使用sapply函数迭代power_par矩阵的行。对于每一行c，执行power_par[c,1]*x^power_par[c,2]，其中power_par[c,1]是幂方程的系数（a），power_par[c,2]是幂指数（b），x^power_par[c,2]是x的幂次方。之后，使用t函数对结果进行转置，以确保返回值是一个列向量，其中包含了所有y值的计算结果。

总的来说，这个函数根据提供的x向量和幂方程的参数（系数和指数），计算并返回对应的y值。这个函数在统计和数据分析中非常有用，特别是在拟合或评估幂律分布时。

power_equation_base源代码

#' @title use power equation to fit observed values
#' @param x vector for x values
#' @param y vector for y valyes
#' @return nls model
#' @examples
#' power_equation_base(c(1,2,3,5,7), c(5,10,15,17,20))
#' @importFrom stats nls nls.control runif lm
#' @export
power_equation_base <- function(x, y){
  x <- as.numeric(x)
  y <- as.numeric(y)
  min_value = min(y[y!=0])

  lmFit <- lm( log( y + runif(1, min = 0, max = min_value))  ~ log(x))
  coefs <- coef(lmFit)
  a <- exp(coefs[1])
  b <- coefs[2]

  model <- try(nls(y~a*x^b,start = list(a = a, b = b),
                   control = nls.control(maxiter = 1e3, minFactor = 1e-200)))
  if( 'try-error' %in% class(model)) {
    result = NULL
  }
  else{
    result = model
  }
  return(result)
}

该R语言代码段定义了一个名为power_equation_base的函数，其目的是使用幂方程来拟合观测值。这个函数可以用于非线性回归分析，特别是当你有理由相信数据遵循幂律分布时。下面是对代码的逐行解释：

1-5. 注释行：

• #' @title: 函数的标题说明。
• #' @param x: 说明第一个参数x，它是一个包含x值的向量。
• #' @param y: 说明第二个参数y，它是一个包含y值的向量。
• #' @return: 说明函数返回的是一个nls（非线性最小二乘）模型。
• #' @examples: 提供了一个示例调用。
• #' @importFrom stats: 指示从stats包导入nls、nls.control、runif和lm函数。
• #' @export: 指示这个函数应该被导出并使其可用于包的用户。

6. 函数定义power_equation_base <- function(x, y){ ... }：
   开始定义函数，它接受两个参数：x和y，分别代表独立变量和因变量的向量值。

7-8. 类型转换：
将x和y强制转换为数值类型，以确保后续的计算不会因类型问题出错。

9. 计算min_value：
   计算y向量中非零值的最小值，随后在求对数变换时将用于避免对数函数的定义域问题。

10-13. 初始线性模型拟合lmFit：
使用线性模型lm对变换后的y值（取对数，加上一个小随机数以避免对数为负无穷的问题）和变换后的x值（取对数）进行回归分析。这有助于为接下来的非线性拟合提供良好的起始估计值。

14-15. 提取系数以获得幂方程的参数：
从线性模型中提取系数，a为幂方程的系数（通过指数转换获得），b为幂指数。

16-18. 尝试非线性最小二乘拟合model：
使用nls函数尝试拟合幂方程模型y ~ a * x^b。start参数提供了初始的系数估计值。control参数设置了算法的控制选项，例如最大迭代次数和算法收敛的最小因子。

19-24. 错误处理：
使用try函数捕获nls执行中可能发生的错误。如果拟合过程中出现错误，model变量将包含一个错误类，此时函数会将result设置为NULL，否则result将包含拟合模型。

25. 返回值：
    函数返回最终result，它可能是一个nls模型对象或NULL。

这个函数是一个数据分析工具，用于确定最佳的a和b参数，使得给定数据集中的y值能够通过幂方程y = a * x^b来最好地表示。通过这种方式，数据分析师可以量化和建模自变量x和因变量y之间的幂律关系。

power_equation_all源代码

#' @title use power equation to fit observed values
#' @param x vector for x values
#' @param y vector for y values
#' @param maxit numeric value for maximum initial pars try
#' @return nls model
#' @examples
#' power_equation_all(c(1,2,3,5,7), c(5,10,15,17,20))
#' @export
power_equation_all <- function(x,y, maxit=1e2){
  result <- power_equation_base(x,y)
  iter <- 1
  while( is.null(result) && iter <= maxit) {
    iter <- iter + 1
    try(result <- power_equation_base(x,y))
  }
  return(result)
}

这段代码是用R语言编写的，其中包含了一个名为 power_equation_all 的函数定义以及相关的文档注释。下面是对每一部分的解释：

1-7. Roxygen2风格的文档注释：

• #' @title 表明这个函数的目的是使用幂函数方程来拟合观测值。
• #' @param x 描述了参数 x 是用于 x 值的向量。
• #' @param y 描述了参数 y 是用于 y 值的向量。
• #' @param maxit 描述了参数 maxit 是尝试初始参数最大次数的数值。
• #' @return 说明函数返回一个非线性最小二乘模型（nls 模型）。
• #' @examples 提供了一个使用示例，演示了如何调用 power_equation_all 函数。
• #' @export 指示该函数应该被导出，使得它可以在包的命名空间之外被用户访问。

8-15. power_equation_all 函数定义：

• 函数接收三个参数：x (x 值向量), y (y 值向量), 和 maxit (最大尝试次数，默认为100)。
• 函数开始时首先尝试使用 power_equation_base 函数来拟合数据，结果存储在 result 变量中。
• 初始化 iter 变量为1，表示当前的尝试次数。
• while 循环用于处理 power_equation_base 函数失败的情况（即当 result 是 NULL 时），并且只要尝试次数没有超过 maxit，就会继续尝试。
• 在循环内，iter 递增，使用 try 函数再次调用 power_equation_base 函数。如果调用成功，result 将不再是 NULL，循环将结束。
• 一旦找到成功的拟合或者达到最大尝试次数，函数返回 result，即拟合的模型或者 NULL（如果拟合失败）。

请注意，该代码片段假设 power_equation_base 函数是在其他地方定义的，它应该尝试拟合一个幂函数方程到给定的 (x, y) 数据点，并返回一个 nls 模型对象。如果 power_equation_base 函数不存在或者没有正确实现，power_equation_all 函数将不会按预期工作。