From 803274cb80866aeee3af8412005466520565f37d Mon Sep 17 00:00:00 2001 From: Richard Wong Date: Tue, 7 May 2024 08:41:39 +0900 Subject: [PATCH] Feat: benchmarked north, rome and steinlib --- .gitignore | 4 - benchmark_results/north/.gitignore | 7 + benchmark_results/north/benchmark_north.bash | 33 ++ benchmark_results/rome/.gitignore | 6 + benchmark_results/rome/benchmark_rome.bash | 33 ++ benchmark_results/steinlib/.gitignore | 9 + data_process/.gitignore | 3 + data_process/file_process_north.bash | 26 ++ data_process/file_process_rome.bash | 28 ++ find_non_planar/.gitignore | 4 + find_non_planar/find_non_planar_north.bash | 32 ++ find_non_planar/find_non_planar_rome.bash | 34 ++ find_non_planar/find_non_planar_steinlib.bash | 34 ++ make_graphs/.gitignore | 2 + make_planar/.gitignore | 1 + make_planar/get_graph_characteristics.cpp | 26 ++ make_planar/graphml_to_gml.cpp | 27 ++ make_planar/ogdf_mps_cactus.cpp | 29 +- make_planar/ogdf_mps_fast.cpp | 28 +- make_planar/ogdf_test_planar.cpp | 29 ++ notebooks/statistics.ipynb | 296 ++++++++++++++++++ 21 files changed, 658 insertions(+), 33 deletions(-) create mode 100644 benchmark_results/north/.gitignore create mode 100644 benchmark_results/north/benchmark_north.bash create mode 100644 benchmark_results/rome/.gitignore create mode 100644 benchmark_results/rome/benchmark_rome.bash create mode 100644 benchmark_results/steinlib/.gitignore create mode 100644 data_process/.gitignore create mode 100644 data_process/file_process_north.bash create mode 100644 data_process/file_process_rome.bash create mode 100644 find_non_planar/.gitignore create mode 100644 find_non_planar/find_non_planar_north.bash create mode 100644 find_non_planar/find_non_planar_rome.bash create mode 100644 find_non_planar/find_non_planar_steinlib.bash create mode 100644 make_graphs/.gitignore create mode 100644 make_planar/.gitignore create mode 100644 make_planar/get_graph_characteristics.cpp create mode 100644 make_planar/graphml_to_gml.cpp create mode 100644 make_planar/ogdf_test_planar.cpp create mode 100644 notebooks/statistics.ipynb diff --git a/.gitignore b/.gitignore index 69b046a..578a7c4 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,3 @@ .vscode -make_graphs/bin -make_graphs/test_graphs -make_planar/bin test_area -dpt graph_datasets diff --git a/benchmark_results/north/.gitignore b/benchmark_results/north/.gitignore new file mode 100644 index 0000000..43a911f --- /dev/null +++ b/benchmark_results/north/.gitignore @@ -0,0 +1,7 @@ +dpt_planarizer +north.txt +north_result.csv +north_subset.txt +ogdf_mps_fast +output_north_dfs.txt +output_north_fast.txt diff --git a/benchmark_results/north/benchmark_north.bash b/benchmark_results/north/benchmark_north.bash new file mode 100644 index 0000000..651235c --- /dev/null +++ b/benchmark_results/north/benchmark_north.bash @@ -0,0 +1,33 @@ +#!/bin/bash + +FILE_LIST=$1 + +PROGRAM=$2 + + +# Check if file_list.txt exists +if [ ! -f $FILE_LIST ]; then + echo "input file not found!" + exit 1 +fi + +INPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/north/gml_non_planar/ + +# Read file paths from file_list.txt +while IFS= read -r INPUT_FILE; do + # Extract filename stem + filename=$(basename -- "$INPUT_FILE") + filename_stem="${filename%.*}" + + + # Run your program and capture its output + if [ "$PROGRAM" == "ogdf_mps_fast" ]; then + # do something if strings are equal + ./$PROGRAM "$INPUT_PATH$INPUT_FILE" + elif [ "$PROGRAM" == "dpt_planarizer" ]; then + # do something if strings are not equal + ./$PROGRAM "$INPUT_PATH$INPUT_FILE" 1000 + fi + + +done < $FILE_LIST diff --git a/benchmark_results/rome/.gitignore b/benchmark_results/rome/.gitignore new file mode 100644 index 0000000..093fa52 --- /dev/null +++ b/benchmark_results/rome/.gitignore @@ -0,0 +1,6 @@ +dpt_planarizer +ogdf_mps_fast +output_rome_dfs.txt +output_rome_fast.txt +rome.txt +rome_result.csv diff --git a/benchmark_results/rome/benchmark_rome.bash b/benchmark_results/rome/benchmark_rome.bash new file mode 100644 index 0000000..ed68323 --- /dev/null +++ b/benchmark_results/rome/benchmark_rome.bash @@ -0,0 +1,33 @@ +#!/bin/bash + +FILE_LIST=$1 + +PROGRAM=$2 + + +# Check if file_list.txt exists +if [ ! -f $FILE_LIST ]; then + echo "input file not found!" + exit 1 +fi + +INPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/rome/gml_non_planar/ + +# Read file paths from file_list.txt +while IFS= read -r INPUT_FILE; do + # Extract filename stem + filename=$(basename -- "$INPUT_FILE") + filename_stem="${filename%.*}" + + + # Run your program and capture its output + if [ "$PROGRAM" == "ogdf_mps_fast" ]; then + # do something if strings are equal + ./$PROGRAM "$INPUT_PATH$INPUT_FILE" + elif [ "$PROGRAM" == "dpt_planarizer" ]; then + # do something if strings are not equal + ./$PROGRAM "$INPUT_PATH$INPUT_FILE" 1000 + fi + + +done < $FILE_LIST diff --git a/benchmark_results/steinlib/.gitignore b/benchmark_results/steinlib/.gitignore new file mode 100644 index 0000000..c624765 --- /dev/null +++ b/benchmark_results/steinlib/.gitignore @@ -0,0 +1,9 @@ +benchmark_steinlib.bash +dpt_planarizer +dpt_planarizer_random +dpt_planarizer_wilson +get_graph_char +ogdf_mps_cactus +ogdf_mps_fast +output_steinlib_* +steinlib.txt diff --git a/data_process/.gitignore b/data_process/.gitignore new file mode 100644 index 0000000..5156674 --- /dev/null +++ b/data_process/.gitignore @@ -0,0 +1,3 @@ +graphml_to_gml +north_input.txt +rome_input.txt diff --git a/data_process/file_process_north.bash b/data_process/file_process_north.bash new file mode 100644 index 0000000..2395ebf --- /dev/null +++ b/data_process/file_process_north.bash @@ -0,0 +1,26 @@ +#!/bin/bash + +FILE_LIST=$1 + +echo "$FILE_LIST" + +# Check if file_list.txt exists +if [ ! -f $FILE_LIST ]; then + echo "input file not found!" + exit 1 +fi + +INPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/north/graphml/ + +# Read file paths from file_list.txt +while IFS= read -r INPUT_FILE; do + # Extract filename stem + filename=$(basename -- "$INPUT_FILE") + filename_stem="${filename%.*}" + + # Modify output path + OUTPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/north/gml/"$filename_stem".gml + + # Call your program with input and modified output paths + ./graphml_to_gml "$INPUT_PATH$INPUT_FILE" "$OUTPUT_PATH" +done < $FILE_LIST diff --git a/data_process/file_process_rome.bash b/data_process/file_process_rome.bash new file mode 100644 index 0000000..2731514 --- /dev/null +++ b/data_process/file_process_rome.bash @@ -0,0 +1,28 @@ +#!/bin/bash + +FILE_LIST=$1 + +echo "$FILE_LIST" + +# Check if file_list.txt exists +if [ ! -f $FILE_LIST ]; then + echo "input file not found!" + exit 1 +fi + +INPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/rome/graphml/ + +# Read file paths from file_list.txt +while IFS= read -r INPUT_FILE; do + # Extract filename stem + filename=$(basename -- "$INPUT_FILE") + filename_stem="${filename%.*}" + + # Modify output path + OUTPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/rome/gml/"$filename_stem".gml + + echo "$filename_stem" + + # Call your program with input and modified output paths + ./graphml_to_gml "$INPUT_PATH$INPUT_FILE" "$OUTPUT_PATH" +done < $FILE_LIST diff --git a/find_non_planar/.gitignore b/find_non_planar/.gitignore new file mode 100644 index 0000000..6cc7bc1 --- /dev/null +++ b/find_non_planar/.gitignore @@ -0,0 +1,4 @@ +north_gml_input.txt +ogdf_test_planar +rome_gml_input.txt +steinlib_gml_input.txt diff --git a/find_non_planar/find_non_planar_north.bash b/find_non_planar/find_non_planar_north.bash new file mode 100644 index 0000000..8601a54 --- /dev/null +++ b/find_non_planar/find_non_planar_north.bash @@ -0,0 +1,32 @@ +#!/bin/bash + +FILE_LIST=$1 + +echo "$FILE_LIST" + +# Check if file_list.txt exists +if [ ! -f $FILE_LIST ]; then + echo "input file not found!" + exit 1 +fi + +INPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/north/gml/ + +# Read file paths from file_list.txt +while IFS= read -r INPUT_FILE; do + # Extract filename stem + filename=$(basename -- "$INPUT_FILE") + filename_stem="${filename%.*}" + + # Modify output path + OUTPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/north/gml_non_planar/ + + # Run your program and capture its output + output=$(./ogdf_test_planar "$INPUT_PATH$INPUT_FILE") + + # Check the output and perform actions accordingly + if [ "$output" -eq 0 ]; then + # it is not planar, copy to folder + cp "$INPUT_PATH$INPUT_FILE" "$OUTPUT_PATH$INPUT_FILE" + fi +done < $FILE_LIST diff --git a/find_non_planar/find_non_planar_rome.bash b/find_non_planar/find_non_planar_rome.bash new file mode 100644 index 0000000..891bf65 --- /dev/null +++ b/find_non_planar/find_non_planar_rome.bash @@ -0,0 +1,34 @@ +#!/bin/bash + +FILE_LIST=$1 + +echo "$FILE_LIST" + +# Check if file_list.txt exists +if [ ! -f $FILE_LIST ]; then + echo "input file not found!" + exit 1 +fi + +INPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/rome/gml/ + +# Read file paths from file_list.txt +while IFS= read -r INPUT_FILE; do + # Extract filename stem + filename=$(basename -- "$INPUT_FILE") + filename_stem="${filename%.*}" + + # Modify output path + OUTPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/rome/gml_non_planar/ + + # Run your program and capture its output + output=$(./ogdf_test_planar "$INPUT_PATH$INPUT_FILE") + + echo "$filename_stem" + + # Check the output and perform actions accordingly + if [ "$output" -eq 0 ]; then + # it is not planar, copy to folder + cp "$INPUT_PATH$INPUT_FILE" "$OUTPUT_PATH$INPUT_FILE" + fi +done < $FILE_LIST diff --git a/find_non_planar/find_non_planar_steinlib.bash b/find_non_planar/find_non_planar_steinlib.bash new file mode 100644 index 0000000..86cd29e --- /dev/null +++ b/find_non_planar/find_non_planar_steinlib.bash @@ -0,0 +1,34 @@ +#!/bin/bash + +FILE_LIST=$1 + +echo "$FILE_LIST" + +# Check if file_list.txt exists +if [ ! -f $FILE_LIST ]; then + echo "input file not found!" + exit 1 +fi + +INPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/steinlib/data/ + +# Read file paths from file_list.txt +while IFS= read -r INPUT_FILE; do + # Extract filename stem + filename=$(basename -- "$INPUT_FILE") + filename_stem="${filename%.*}" + + # Modify output path + OUTPUT_PATH=/home/richard/Projects/06_research/maximum_planar_subgraph/benchmark_data/graph_datasets/steinlib/gml_non_planar/ + + # Run your program and capture its output + output=$(./ogdf_test_planar "$INPUT_PATH$INPUT_FILE") + + echo "$filename_stem" + + # Check the output and perform actions accordingly + if [ "$output" -eq 0 ]; then + # it is not planar, copy to folder + cp "$INPUT_PATH$INPUT_FILE" "$OUTPUT_PATH$INPUT_FILE" + fi +done < $FILE_LIST diff --git a/make_graphs/.gitignore b/make_graphs/.gitignore new file mode 100644 index 0000000..79f5849 --- /dev/null +++ b/make_graphs/.gitignore @@ -0,0 +1,2 @@ +bin +test_graphs diff --git a/make_planar/.gitignore b/make_planar/.gitignore new file mode 100644 index 0000000..ba077a4 --- /dev/null +++ b/make_planar/.gitignore @@ -0,0 +1 @@ +bin diff --git a/make_planar/get_graph_characteristics.cpp b/make_planar/get_graph_characteristics.cpp new file mode 100644 index 0000000..d1f2968 --- /dev/null +++ b/make_planar/get_graph_characteristics.cpp @@ -0,0 +1,26 @@ +/* This code converts GraphML to gml + * + */ +#include + +#include + +using namespace ogdf; + + +int main(int argc, char* argv[]) +{ + + string input_file = argv[1]; + Graph G; + + if (!GraphIO::read(G, input_file, GraphIO::readGML)) { + std::cerr << "Could not read input.gml" << std::endl; + return 1; + } + + std::cout << G.numberOfNodes() << ", " << G.numberOfEdges() << std::endl; + + + return 0; +} diff --git a/make_planar/graphml_to_gml.cpp b/make_planar/graphml_to_gml.cpp new file mode 100644 index 0000000..fcc8ce8 --- /dev/null +++ b/make_planar/graphml_to_gml.cpp @@ -0,0 +1,27 @@ +/* This code converts GraphML to gml + * + */ +#include + +#include + +using namespace ogdf; + + +int main(int argc, char* argv[]) +{ + + string input_file = argv[1]; + Graph G; + + if (!GraphIO::read(G, input_file, GraphIO::readGraphML)) { + std::cerr << "Could not read input.gml" << std::endl; + return 1; + } + + string output_file = argv[2]; + GraphIO::write(G, output_file, GraphIO::writeGML); + + + return 0; +} diff --git a/make_planar/ogdf_mps_cactus.cpp b/make_planar/ogdf_mps_cactus.cpp index ff35e5c..6f1a24d 100644 --- a/make_planar/ogdf_mps_cactus.cpp +++ b/make_planar/ogdf_mps_cactus.cpp @@ -24,20 +24,19 @@ int main(int argc, char* argv[]) NodeArray numbering(G); - int num = computeSTNumbering(G, numbering, nullptr, nullptr, true); + computeSTNumbering(G, numbering, nullptr, nullptr, true); OGDF_ASSERT(num == G.numberOfNodes()); // print after input // graphPrinter(G); - std::cout << "G Planarity: " << ogdf::isPlanar(G) << std::endl; - std::cout << "Original number of nodes: " << G.numberOfNodes() << std::endl; - std::cout << "Original number of edges: " << G.numberOfEdges() << std::endl; + // std::cout << "G Planarity: " << ogdf::isPlanar(G) << std::endl; + // std::cout << "Original number of nodes: " << G.numberOfNodes() << std::endl; + // std::cout << "Original number of edges: " << G.numberOfEdges() << std::endl; // separator for planarization // <--------------> - // PQ implementation to make planar subgraph - std::cout << "start planarization" << std::endl; + // std::cout << "start planarization" << std::endl; List *delEdges = new List; // empty list PlanarSubgraphCactus psc; @@ -45,24 +44,24 @@ int main(int argc, char* argv[]) mps.call(G, *delEdges); - std::cout << "Edges removed:" << delEdges->size() << std::endl; + std::cout << delEdges->size() << std::endl; // delete removed edges - for (edge e: *delEdges) { - // print removed edges - // std::cout << e->adjSource() << std::endl; - G.delEdge(e); - } + //for (edge e: *delEdges) { + // // print removed edges + // // std::cout << e->adjSource() << std::endl; + // G.delEdge(e); + //} // write processed graph to new gml file // GraphIO::write(G, "output.gml", GraphIO::writeGML); - std::cout << "G planarity: " << ogdf::isPlanar(G) << std::endl; - std::cout << "Original number of nodes: " << G.numberOfNodes() << std::endl; - std::cout << "Subgraph number of edges: " << G.numberOfEdges() << std::endl; + // std::cout << ogdf::isPlanar(G) << std::endl; + // std::cout << "Original number of nodes: " << G.numberOfNodes() << std::endl; + // std::cout << "Subgraph number of edges: " << G.numberOfEdges() << std::endl; return 0; diff --git a/make_planar/ogdf_mps_fast.cpp b/make_planar/ogdf_mps_fast.cpp index df5786d..bfbdb2c 100644 --- a/make_planar/ogdf_mps_fast.cpp +++ b/make_planar/ogdf_mps_fast.cpp @@ -27,20 +27,19 @@ int main(int argc, char* argv[]) NodeArray numbering(G); - int num = computeSTNumbering(G, numbering, nullptr, nullptr, true); + computeSTNumbering(G, numbering, nullptr, nullptr, true); OGDF_ASSERT(num == G.numberOfNodes()); // print after input // graphPrinter(G); - std::cout << "G Planarity: " << ogdf::isPlanar(G) << std::endl; - std::cout << "Original number of nodes: " << G.numberOfNodes() << std::endl; - std::cout << "Original number of edges: " << G.numberOfEdges() << std::endl; + // std::cout << "G Planarity: " << ogdf::isPlanar(G) << std::endl; + // std::cout << "Original number of nodes: " << G.numberOfNodes() << std::endl; + // std::cout << "Original number of edges: " << G.numberOfEdges() << std::endl; // separator for planarization // <--------------> // PQ implementation to make planar subgraph - std::cout << "start planarization" << std::endl; List *delEdges = new List; // empty list PlanarSubgraphFast psf; @@ -50,24 +49,25 @@ int main(int argc, char* argv[]) mps.call(G, *delEdges); - std::cout << "Edges removed:" << delEdges->size() << std::endl; + // print edges removed + std::cout << delEdges->size() << std::endl; // delete removed edges - for (edge e: *delEdges) { - // print removed edges - // std::cout << e->adjSource() << std::endl; - G.delEdge(e); - } + // for (edge e: *delEdges) { + // // print removed edges + // // std::cout << e->adjSource() << std::endl; + // G.delEdge(e); + // } // write processed graph to new gml file // GraphIO::write(G, "output.gml", GraphIO::writeGML); - std::cout << "G planarity: " << ogdf::isPlanar(G) << std::endl; - std::cout << "Original number of nodes: " << G.numberOfNodes() << std::endl; - std::cout << "Subgraph number of edges: " << G.numberOfEdges() << std::endl; + // std::cout << "G planarity: " << ogdf::isPlanar(G) << std::endl; + // std::cout << "Original number of nodes: " << G.numberOfNodes() << std::endl; + // std::cout << "Subgraph number of edges: " << G.numberOfEdges() << std::endl; return 0; diff --git a/make_planar/ogdf_test_planar.cpp b/make_planar/ogdf_test_planar.cpp new file mode 100644 index 0000000..a2efb86 --- /dev/null +++ b/make_planar/ogdf_test_planar.cpp @@ -0,0 +1,29 @@ +/* This code only tests the graph for planarity + * + */ +#include +#include + +#include + +using namespace ogdf; + + +int main(int argc, char* argv[]) +{ + + string inputFile = argv[1]; + Graph G; + + if (!GraphIO::read(G, inputFile, GraphIO::readGML)) { + std::cerr << "Could not read input.gml" << std::endl; + return 1; + } + + // print after input + // graphPrinter(G); + std::cout << ogdf::isPlanar(G) << std::endl; + + + return 0; +} diff --git a/notebooks/statistics.ipynb b/notebooks/statistics.ipynb new file mode 100644 index 0000000..2e0eb68 --- /dev/null +++ b/notebooks/statistics.ipynb @@ -0,0 +1,296 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# North" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df = pd.read_csv('../benchmark_results/north/north_result.csv', header=None)\n", + "df\n", + "diff = df[1] - df[2]\n", + "\n", + "# Sample data\n", + "\n", + "# Plotting the violin plot\n", + "sns.violinplot(data=diff, color='skyblue')\n", + "\n", + "# Adding labels and title\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.title('Violin Plot for North Diffs')\n", + "\n", + "# Displaying the plot\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rome" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df = pd.read_csv('../benchmark_results/rome/rome_result.csv', header=None)\n", + "diff = df[1] - df[2]\n", + "\n", + "# Sample data\n", + "\n", + "# Plotting the violin plot\n", + "sns.violinplot(data=diff, color='skyblue')\n", + "\n", + "# Adding labels and title\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.title('Violin Plot for Rome Diffs')\n", + "\n", + "# Displaying the plot\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012
0grafo10000.38.gml33
1grafo10003.40.gml11
2grafo10005.39.gml32
3grafo10006.98.gml1411
4grafo10008.42.gml44
............
8248grafo9994.91.gml1010
8249grafo9995.94.gml2018
8250grafo9997.40.gml22
8251grafo9998.38.gml11
8252grafo9999.39.gml22
\n", + "

8253 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " 0 1 2\n", + "0 grafo10000.38.gml 3 3\n", + "1 grafo10003.40.gml 1 1\n", + "2 grafo10005.39.gml 3 2\n", + "3 grafo10006.98.gml 14 11\n", + "4 grafo10008.42.gml 4 4\n", + "... ... .. ..\n", + "8248 grafo9994.91.gml 10 10\n", + "8249 grafo9995.94.gml 20 18\n", + "8250 grafo9997.40.gml 2 2\n", + "8251 grafo9998.38.gml 1 1\n", + "8252 grafo9999.39.gml 2 2\n", + "\n", + "[8253 rows x 3 columns]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Steinlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df = pd.read_csv('../benchmark_results/steinlib/steinlib_result.csv', header=None)\n", + "diff = df[1] - df[2]\n", + "\n", + "# Sample data\n", + "\n", + "# Plotting the violin plot\n", + "sns.violinplot(data=diff, color='skyblue')\n", + "\n", + "# Adding labels and title\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.title('Violin Plot for Rome Diffs')\n", + "\n", + "# Displaying the plot\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}