Início / coding / Perguntas / 79176054
Accepted
user430997
Asked: 2024-11-11 07:54:19 +0800 CST

Qual ponto está mais próximo da média de todos os pontos?

  • 772

Tenho este gráfico em R em que cada nó tem um peso aleatório:

library(igraph)
library(tidyverse)
set.seed(123)

g <- sample_gnm(n = 20, m = 30, directed = FALSE)
V(g)$weight <- runif(20)

Estou tentando descobrir qual nó tem um peso mais próximo da média de todos os nós.

Se isso não fosse um gráfico de rede, seria bem fácil de fazer. No entanto, não tenho certeza de como fazer isso usando um objeto de gráfico de rede.

Tentei fazer isso da seguinte maneira:

tibble(
    node_id = 1:20,
    weight = V(g)$weight,
    mean_weight_of_all_nodes = mean(V(g)$weight),
    abs_distance_from_mean = abs(weight - mean_weight_of_all_nodes)
) %>%
    arrange(abs_distance_from_mean) %>%
    mutate(rank = row_number())

O resultado fica assim:

# A tibble: 20 × 5
   node_id weight mean_weight_of_all_nodes abs_distance_from_mean  rank
     <int>  <dbl>                    <dbl>                  <dbl> <int>
 1      12 0.414                     0.396                 0.0180     1
 2      11 0.415                     0.396                 0.0188     2
 3      13 0.369                     0.396                 0.0269     3
 4      17 0.466                     0.396                 0.0702     4
 5       8 0.318                     0.396                 0.0776     5
 6       5 0.478                     0.396                 0.0820     6
 7      18 0.266                     0.396                 0.130      7
 8      16 0.233                     0.396                 0.163      8
 9       9 0.232                     0.396                 0.164      9
10       7 0.216                     0.396                 0.179     10
11      14 0.152                     0.396                 0.243     11
12      10 0.143                     0.396                 0.253     12
13      15 0.139                     0.396                 0.257     13
14       2 0.691                     0.396                 0.295     14
15      20 0.0458                    0.396                 0.350     15
16       6 0.758                     0.396                 0.363     16
17       4 0.0246                    0.396                 0.371     17
18       3 0.795                     0.396                 0.400     18
19      19 0.858                     0.396                 0.462     19
20       1 0.902                     0.396                 0.507     20

Essa é a maneira correta de fazer isso?

4 respostas

  1. Best Answer

    Sua implementação está correta e pode ser simplificada para:

    library(igraph)

# same graph from the question
set.seed(123)
g <- sample_gnm(n = 20, m = 30, directed = FALSE)
V(g)$weight <- runif(20)

mean_weight <- mean(V(g)$weight)

# find the node with weight closest to the mean
closest_node <- which.min(abs(V(g)$weight - mean_weight))

list(
  "node id" = closest_node,
  "node weight" = V(g)$weight[closest_node],
  "mean weight" = mean_weight
)

> list(
+   "node id" = closest_node,
+   "node weight" = V(g)$weight[closest_node],
+   "mean weight" = mean_weight
+ )
$`node id`
[1] 12

$`node weight`
[1] 0.4137243

$`mean weight`
[1] 0.3957675
    • 4

  2. Se isto não fosse um gráfico de rede /.../

    Você pode gostar do tidygraph .

    /.../ uma API organizada para manipulação de grafos/redes. Embora os dados de rede em si não sejam organizados, eles podem ser visualizados como duas tabelas organizadas, uma para dados de nós e uma para dados de arestas. /.../

    library(igraph)
library(dplyr)
library(tidygraph)
set.seed(123)

g <- sample_gnm(n = 20, m = 30, directed = FALSE)
V(g)$weight <- runif(20)

g_ranked <- 
  as_tbl_graph(g) |> 
  activate(nodes) |> 
  mutate(
    abs_distance_from_mean = abs(weight - mean(weight)),
    rank = row_number(abs_distance_from_mean)
  )
g_ranked
#> # A tbl_graph: 20 nodes and 30 edges
#> #
#> # An undirected simple graph with 1 component
#> #
#> # Node Data: 20 × 3 (active)
#>    weight abs_distance_from_mean  rank
#>     <dbl>                  <dbl> <int>
#>  1 0.902                  0.507     20
#>  2 0.691                  0.295     14
#>  3 0.795                  0.400     18
#>  4 0.0246                 0.371     17
#>  5 0.478                  0.0820     6
#>  6 0.758                  0.363     16
#>  7 0.216                  0.179     10
#>  8 0.318                  0.0776     5
#>  9 0.232                  0.164      9
#> 10 0.143                  0.253     12
#> 11 0.415                  0.0188     2
#> 12 0.414                  0.0180     1
#> 13 0.369                  0.0269     3
#> 14 0.152                  0.243     11
#> 15 0.139                  0.257     13
#> 16 0.233                  0.163      8
#> 17 0.466                  0.0702     4
#> 18 0.266                  0.130      7
#> 19 0.858                  0.462     19
#> 20 0.0458                 0.350     15
#> #
#> # Edge Data: 30 × 2
#>    from    to
#>   <int> <int>
#> 1     1     3
#> 2     2     5
#> 3     3     5
#> # ℹ 27 more rows

    g_ranked |> 
  slice_min(rank) |> 
  as_tibble()
#> # A tibble: 1 × 3
#>   weight abs_distance_from_mean  rank
#>    <dbl>                  <dbl> <int>
#> 1  0.414                 0.0180     1

    Criado em 2024-11-11 com reprex v2.1.1

    • 1

  3. Outra opção pode ser as_long_data_frame()+within()

    library(igraph)
as_data_frame(g, what = "vertices") |>
  within({
    mean_weight = mean(weight) 
    abs_diff = abs(weight - mean_weight)
    }) |> sort_by(~abs_diff)

    dando

        weight   abs_diff mean_weight
12 0.41372433 0.01795679   0.3957675
11 0.41454634 0.01877880   0.3957675
13 0.36884545 0.02692208   0.3957675
17 0.46596245 0.07019492   0.3957675
8  0.31818101 0.07758653   0.3957675

    Observe que o data frame está classificado. Um rankcálculo explícito é a alternativa. Podemos querer mover os nomes das linhas para uma coluna de identificador.

    • 1

  4. Você pode fazer a mesma coisa que fez antes, mas só precisa gerar um dataframe a partir deg

    g %>%
  {
    data.frame(node_id = V(.), weight = V(.)$weight)
  } %>%
  mutate(
    mean_weight_of_all_nodes = mean(V(g)$weight),
    abs_distance_from_mean = abs(weight - mean_weight_of_all_nodes)
  ) %>%
  arrange(abs_distance_from_mean) %>%
  mutate(rank = row_number())

    o que dá

       node_id     weight mean_weight_of_all_nodes abs_distance_from_mean rank
1       12 0.41372433                0.3957675             0.01795679    1
2       11 0.41454634                0.3957675             0.01877880    2
3       13 0.36884545                0.3957675             0.02692208    3
4       17 0.46596245                0.3957675             0.07019492    4
5        8 0.31818101                0.3957675             0.07758653    5
6        5 0.47779597                0.3957675             0.08202844    6
7       18 0.26597264                0.3957675             0.12979489    7
8       16 0.23303410                0.3957675             0.16273343    8
9        9 0.23162579                0.3957675             0.16414175    9
10       7 0.21640794                0.3957675             0.17935960   10
11      14 0.15244475                0.3957675             0.24332279   11
12      10 0.14280002                0.3957675             0.25296751   12
13      15 0.13880606                0.3957675             0.25696147   13
14       2 0.69070528                0.3957675             0.29493774   14
15      20 0.04583117                0.3957675             0.34993637   15
16       6 0.75845954                0.3957675             0.36269200   16
17       4 0.02461368                0.3957675             0.37115385   17
18       3 0.79546742                0.3957675             0.39969988   18
19      19 0.85782772                0.3957675             0.46206018   19
20       1 0.90229905                0.3957675             0.50653151   20
    • 1

relate perguntas