library(shiny)
library(shinyjs)
library(bslib)
library(dplyr)
library(ggplot2)
library(tm)
library(SnowballC)
library(plotly)
library(text2vec)
library(tokenizers)
library(dplyr)
library(tidyr)
library(igraph)
library(ggraph)
library(topicmodels)
library(wordcloud)
library(wordcloud2)
library(reshape2)
library(SnowballC)
library(RColorBrewer)
library(syuzhet)
library(cluster)
library(tidytext)
library(word2vec)
library(Rtsne)
library(umap)
library(MASS)
library(koRpus)
library(openxlsx)
library(tools)
library(shinyWidgets)
library(tfdatasets)
library(statnet)
library(UserNetR)
library(visNetwork)
library(networkD3)
options(width = 150)
options(digits = 4, scipen = 1000000000)
options(shiny.maxRequestSize=30*1024^2)
ui <- fluidPage(
theme = bs_theme(version = 5, bootswatch = "spacelab"),
useShinyjs(), # Initialize shinyjs
titlePanel("PtteM Data Science"),
tags$head(tags$link(rel = "stylesheet", href="https://fonts.googleapis.com/css?family=Montserrat:100,300,400,700&display=swap"),
tags$style(HTML("
body, h1, h2, h3, h4, h5, h6, .nav, p, a, .shiny-input-container {
font-family: 'Montserrat'; /* Font type for the title attribute */
font-weight: 385;
color: #007c9e !important;
}
* {
font-family: 'Montserrat', sans-serif;
font-weight: 385;
color: #195576; /* Blue color */
}
body {
background-color: #f7f7f7; /* Light gray background */
}
.icon-btn {
border: 1px solid #0d6efd; /* Example border: solid, 2 pixels, #555 color */
border-radius: 15%; /* Circular border */
color: #00969e; /* Icon color */
font-family: 'Montserrat'; /* Font type for the title attribute */
font-weight: 385;
background-color: #f7f7f7;
padding: 125px; /* Space around the icon */
margin: 25px; /* Space around the button */
font-size: 24px; /* Icon size */
box-shadow: 0 2px 4px rgba(0,0,0,0.2);
}
.icon-btn:hover {
color: #00969e; /* Icon color on hover */
border-color: #007c9e;
background-color: #ebfbfd;/* Border color on hover */
}
/* Add custom styles here */
.shiny-input-container {
margin-bottom: 15px;
}
.box {
border: 1px solid #ddd;
padding: 20px;
border-radius: 50px;
margin-bottom: 200px;
gap: 200px;
align-items: center;
}
#statsTable_wrapper {
margin: 0 auto;
}
.shiny-output-error {
border: 1px solid #FF0000; /* Red border on error */
}
/* If you want to change the font size of the tooltip, you can add custom CSS for the 'title' attribute's default styling. */
"))),
tags$head(
# Include JavaScript to reload the page
tags$script(HTML("
document.addEventListener('DOMContentLoaded', function() {
document.getElementById('myElement').style.color = '#0d6efd'; // Change to your desired color
});
"))
),
tags$head(
tags$script(HTML("
function reloadPage() {
window.location.reload();
}
"))
),
# Refresh button that calls the JavaScript function
actionButton("refresh", "Refresh Analysis", onclick = "reloadPage();"),
# Help Text or Information for the user
helpText("Bu uygulama ile sosyal ağlar analizi başlığı altındaki veri bilimi fonksiyonlarına erişebilirsiniz."),
#Social Network Analysis
h2("Social Network Analysis Section"),
tabsetPanel(
tabPanel("Centrality",
tabsetPanel(
tabPanel("Degree Centrality",
sidebarLayout(
sidebarPanel(
fileInput("dcent_input", "Choose CSV/XLSX/XSX File", accept = c(".csv", ".xlsx", ".xsx"), multiple = TRUE),
uiOutput("target_dcent1"),
uiOutput("target_dcent2"),
actionButton("degree_cent_sna", "Degree Centrality Model"),
HTML("
Derece Merkeziliği Bölümü
Bu bölüm, ağın düğümlerinin derece merkeziliğini hesaplamak için kullanılır. Derece merkeziliği, bir düğümün doğrudan bağlantı sayısının bir ölçüsüdür ve ağ içindeki önemini gösterir.
Kullanım Adımları:
- Dosya Yükleme: Analiz için CSV, XLSX veya XSX formatında ağ veri dosyalarını
fileInput
aracılığıyla yükleyin.
- Sütun Seçimi: Ağ kenarlarını oluşturacak sütunları
uiOutput
kullanarak seçin.
- Derece Merkeziliği Modeli:
actionButton
ile modeli çalıştırın ve derece merkeziliği sonuçlarını görselleştirin.
Anlam ve Kullanım:
Derece merkeziliği, bir düğümün diğer tüm düğümlerle olan doğrudan bağlantılarının sayısını ifade eder. Yüksek derece merkeziliğine sahip düğümler, genellikle ağın en etkili ve önemli düğümleridir.
Veri Bilimi Kullanımı:
Derece merkeziliği, ağın en etkin düğümlerini tanımlamak ve ağ yapısını analiz etmek için kullanılır. Bu, sosyal ağ analizi, bağlantı analizi ve pazar analizi gibi çeşitli alanlarda uygulama bulur.
Desteklenen Dosya Tipleri:
CSV, XLSX ve XSX gibi tablo formatlarında dosyalar desteklenmektedir.
Sonuçların Yorumlanması:
Yüksek derece merkeziliğine sahip düğümler, genellikle birçok diğer düğümle bağlantılıdır ve ağın bilgi akışında merkezi bir role sahip olabilirler. Sonuçlar, ağın kilit noktalarını belirlemede ve stratejik planlama yapmada kullanılabilir.
Uygulama Örnekleri:
- Sosyal Ağlarda Etki Analizi: Sosyal ağlarda, derece merkeziliği yüksek kullanıcılar genellikle büyük bir takipçi kitlesine sahiptir ve etkileşimde önemli rol oynarlar.
- Bilgi Yayılımı: Bilgi ve yeniliklerin yayılımında merkezi noktaları belirlemek için derece merkeziliği analizleri kullanılır.
- Organizasyonel Ağlar: Şirket içi ağlarda, derece merkeziliği yüksek çalışanlar önemli bilgi kaynakları olarak görülür ve bu bilgiler stratejik karar alma süreçlerinde değerlendirilir.
Bu bölümde sağlanan araçlar, kullanıcıların ağ yapılarını keşfetmelerini ve değerli içgörüler elde etmelerini sağlar.
")
),
mainPanel(
tabsetPanel(
tabPanel("Degree Centrality Plot", visNetworkOutput("dcent_sna_plot", width = "100%", height = "750px"))
)
)
)
),
tabPanel("Betweenness Centrality",
sidebarLayout(
sidebarPanel(
fileInput("bc_input", "Choose data file", accept = c(".csv", ".xlsx", ".xsx")),
uiOutput("bc_target"), # Dynamic UI for selecting variables
actionButton("bc_calculate", "Calculate Betweenness Centrality"),
HTML("
Aralıklık Merkeziliği Bölümü
Bu bölüm, düğümlerin ağ üzerindeki köprü rolünün bir ölçüsü olan aralıklık merkeziliğini hesaplamak için kullanıcıların veri yüklemesine, değişken seçimine ve merkezilik analizini gerçekleştirmesine olanak tanır.
Kullanım Adımları:
- Veri Dosyası Yükleme: Analiz için
fileInput
aracılığıyla CSV veya XLSX formatında veri dosyası yükleyin.
- Değişken Seçimi: Ağ yapısını oluşturacak değişkenleri
uiOutput
aracılığıyla seçin.
- Aralıklık Merkeziliği Hesaplama:
actionButton
ile aralıklık merkeziliği hesaplamasını başlatın ve sonuçları görselleştirin.
Anlam ve Kullanım:
Aralıklık merkeziliği, düğümlerin ağ içindeki en kısa yollar üzerindeki varlığının bir ölçüsüdür ve bu düğümlerin ağdaki diğer düğümler arasındaki etkileşimler üzerindeki potansiyel kontrolünü gösterir.
Veri Bilimi Kullanımı:
Aralıklık merkeziliği analizi, sosyal ağ analizi, iletişim ağları ve ulaşım ağları gibi alanlarda kritik öneme sahip düğümleri belirlemek için kullanılır.
Desteklenen Dosya Tipleri:
CSV ve XLSX formatları desteklenmektedir.
Sonuçların Yorumlanması:
Yüksek aralıklık merkeziliğine sahip düğümler genellikle ağ üzerinde stratejik konumlara sahiptir ve ağ içindeki bilgi veya kaynak akışının kontrol noktaları olabilirler. Sonuçlar, stratejik planlama ve ağın kritik bileşenlerini anlamada kullanılabilir.
Uygulama Örnekleri:
- Ulaşım Ağları: Şehir içi ulaşım ağlarında, aralıklık merkeziliği yüksek duraklar veya kavşaklar, trafiğin yoğun olduğu ve önemli olduğu noktaları belirler.
- İletişim Ağları: İletişim ağlarında, mesajların veya verilerin aktarımında merkezi rol oynayan düğümlerin belirlenmesinde kullanılır.
- Sosyal Ağlar: Sosyal ağlarda, kişi veya grupların ağ içindeki etki düzeylerini ve diğer düğümler üzerindeki potansiyel etkilerini anlamada faydalıdır.
Aralıklık merkeziliği analizi, kullanıcıların ağın yapısal önemini anlamalarına ve stratejik düğümleri tanımlamalarına olanak tanır.
")
),
mainPanel(
tabsetPanel(
tabPanel("Betweenness Centrality Output", visNetworkOutput("bc_plot", width = "100%", height = "750px"))
)
)
)
),
tabPanel("Closeness Centrality",
sidebarLayout(
sidebarPanel(
fileInput("cc_input", "Choose CSV/XLSX File", accept = c(".csv", ".xlsx")),
uiOutput("cc_target"),
actionButton("cc_calculate", "Calculate Closeness Centrality"),
HTML("
Yakınlık Merkeziliği Bölümü
Bu bölümde, kullanıcılar bir ağdaki düğümlerin yakınlık merkeziliğini hesaplayabilir. Yakınlık merkeziliği, bir düğümün ağdaki diğer tüm düğümlere ne kadar 'yakın' olduğunu gösteren bir ölçüttür. Yakın olmak, az sayıda adımda diğer tüm düğümlere ulaşabilmek anlamına gelir ve bu da düğümün ağ üzerindeki etkisinin bir göstergesidir.
Kullanım Adımları:
- Dosya Yükleme: Ağ veri dosyasını
fileInput
ile yükleyin. CSV veya XLSX formatlarında olabilir.
- Değişken Seçimi:
uiOutput
aracılığıyla ağın kenarlarını oluşturacak değişken çiftlerini seçin.
- Yakınlık Merkeziliği Hesaplama:
actionButton
'a tıklayarak hesaplamayı başlatın ve visNetworkOutput
'ta sonuçları görüntüleyin.
Analizin Anlamı:
Yüksek yakınlık merkeziliğine sahip düğümler, ağın diğer elemanlarına daha 'yakındır' ve genellikle bilgi veya kaynak akışında merkezi bir rol oynarlar. Bu düğümler, ağda kritik öneme sahip olabilir.
Veri Bilimi Kullanımı:
Yakınlık merkeziliği analizi, iletişim ağları, ulaşım ağları, sosyal ağlar ve diğer tür ağ analizlerinde kullanılır. Ağın kritik noktalarını ve potansiyel zayıflıklarını tespit etmek için önemlidir.
Desteklenen Dosya Tipleri:
CSV ve XLSX formatlarında ağ kenar listelerini içeren dosyalar desteklenmektedir.
Sonuçların Yorumlanması:
Yüksek yakınlık merkeziliğine sahip düğümler genellikle ağdaki bilgi akışının anahtar noktalarıdır. Bu düğümler, ağın verimliliğini ve iletişim kapasitesini artırmada stratejik olarak önemlidir. Analiz sonuçları, ağdaki önemli düğümlerin ve bağlantıların güçlendirilmesine yönelik planlamalar yapılmasını sağlayabilir. Örneğin:
- Ulaşım Planlaması: Ulaşım ağlarında, yüksek yakınlık merkeziliğine sahip duraklar veya kavşaklar, trafiğin hızlandırılması ve verimliliğin artırılması için iyileştirilebilir.
- Hastalık Yayılımı Analizi: Epidemiolojik ağlarda, hastalıkların yayılımında merkezi rol oynayan düğümler, salgın kontrolünde öncelikli olarak gözetilebilir.
- Sosyal Ağ Analizi: Sosyal ağlarda, yakınlık merkeziliği yüksek bireyler, toplumda bilgi veya yeniliklerin yayılmasında etkin rol oynayabilir ve bu kişiler hedeflenerek sosyal etkinliklerin veya kampanyaların etki alanı genişletilebilir.
Bu analizler, ağ yapısını anlamak ve onun üzerine stratejiler geliştirmek için veri biliminde yaygın olarak kullanılmaktadır.
")
),
mainPanel(
visNetworkOutput("cc_plot", width = "100%", height = "750px")
)
)
),
tabPanel("Eigenvector Centrality",
sidebarLayout(
sidebarPanel(
fileInput("eigen_input", "Choose CSV/XLSX/XLS File", accept = c(".csv", ".xlsx", ".xls"), multiple = TRUE),
uiOutput("eigen_column_select"), # UI for selecting columns
actionButton("calculate_eigen", "Calculate Eigenvector Centrality"),
HTML("
Özvektör Merkeziliği Bölümü
Bu bölüm, ağdaki düğümlerin özvektör merkeziliğini hesaplar. Özvektör merkeziliği, bir düğümün ağ içindeki diğer önemli düğümlerle olan bağlantısının bir ölçüsüdür ve bir düğümün ağ üzerindeki etkisinin göstergesidir.
Kullanım Adımları:
- Dosya Yükleme: Ağ veri dosyalarınızı
fileInput
kullanarak yükleyin. CSV, XLSX veya XLS formatlarında olabilir.
- Değişken Seçimi:
uiOutput
ile ağ kenarlarını oluşturacak değişkenleri seçin.
- Özvektör Merkeziliği Hesapla:
actionButton
kullanarak hesaplamayı başlatın ve visNetworkOutput
ile sonuçları görselleştirin.
Analizin Anlamı:
Yüksek özvektör merkeziliği olan düğümler genellikle ağın önemli düğümleriyle güçlü bağlantılara sahiptir ve ağın yapısal özelliklerini belirleyen anahtar noktalardır.
Veri Bilimi Uygulamaları:
Özvektör merkeziliği, sosyal ağ analizi, link analizi, ve güç analizi gibi çeşitli ağ analizleri için kullanılır. Bu, ağın etkileşimini ve düğüm önemini anlamak için temel bir metriktir.
Desteklenen Dosya Tipleri:
CSV, XLSX, ve XLS gibi çeşitli tablo formatları desteklenir.
Sonuçların Yorumlanması:
Yüksek özvektör merkeziliğine sahip düğümler, ağ üzerindeki diğer önemli düğümlerle güçlü ilişkiler kurar. Bu düğümler genellikle ağın bilgi akışı ve kaynak dağıtımı gibi işlevlerinde merkezi bir rol oynar. Analiz sonuçları, stratejik karar verme ve ağ optimizasyonu için kullanılabilir. Örnek olarak:
- İnovasyon Yayılımı: Bir yeniliğin veya fikrin ağ üzerinde nasıl yayıldığını anlamak için özvektör merkeziliği kullanılabilir. Bu, inovasyonun etkisini artırmak ve doğru hedefleri belirlemek için stratejik bilgiler sağlar.
- Akademik İşbirlikleri: Akademik işbirlikleri ağlarında, özvektör merkeziliği yüksek olan kurumlar veya araştırmacılar, araştırma ve yayın etkinliklerinde önemli rol oynar ve işbirliklerini güçlendirmek için fırsatlar sunar.
- Pazar Dinamikleri: Pazar ağlarında, önemli aktörlerin ve pazar dinamiklerinin anlaşılmasında özvektör merkeziliği analizleri kullanılabilir. Bu, rekabet analizi ve pazar stratejilerinin geliştirilmesinde yardımcı olur.
Bu analizler, ağ yapılarının derinlemesine anlaşılması ve buna bağlı olarak veriye dayalı stratejilerin oluşturulması için değerli araçlardır.
")
),
mainPanel(
visNetworkOutput("eigen_plot", width = "100%", height = "750px") # Plot output
)
)
)
)
),
tabPanel("Community Detection",
sidebarLayout(
sidebarPanel(
fileInput("community_input", "Choose CSV/XLSX/XLS File", accept = c(".csv", ".xlsx", ".xls")),
uiOutput("community_column_select"), # UI for selecting columns
actionButton("calculate_community", "Detect Communities"),
HTML("
Topluluk Tespiti Bölümü
Bu bölüm, ağ yapıları içerisindeki toplulukların veya yoğun bağlantılı düğüm gruplarının tespit edilmesi işlemini kolaylaştırır. Kullanıcılar veri yükleyebilir, ilgili sütunları seçebilir ve topluluk tespiti algoritmalarını çalıştırabilir.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
aracılığıyla CSV, XLSX veya XLS formatında ağ veri dosyası yükleyin.
- Sütun Seçimi: Ağın kenarlarını oluşturacak sütunları
uiOutput
ile seçin.
- Topluluk Tespiti:
actionButton
kullanarak topluluk tespiti algoritmasını çalıştırın ve sonuçları görselleştirin.
Anlam ve Kullanım:
Topluluk tespiti, karmaşık ağ yapılarında benzer özellikler gösteren veya sıkı bir şekilde bağlantılı olan düğüm gruplarını belirlemenin bir yoludur. Bu analiz, ağ içindeki yapısal modüllerin ve grupların anlaşılmasına yardımcı olur.
Veri Bilimi Kullanımı:
Sosyal ağ analizi, biyolojik ağlar ve iletişim ağları gibi birçok alanda topluluk tespiti önemli bir araçtır. Bu, ağın genel yapısını anlamak ve önemli düğüm gruplarını tanımlamak için kullanılır.
Desteklenen Dosya Tipleri:
CSV, XLSX ve XLS dosya formatları desteklenmektedir.
Sonuçların Yorumlanması:
Topluluk tespiti sonuçları, ağ içindeki düğüm gruplarının nasıl organize olduğunu gösterir. Her topluluk, benzer özelliklere sahip veya yoğun bir şekilde birbirine bağlı düğümler grubunu temsil eder. Bu bilgiler, ağın alt yapılarını anlamak ve önemli toplulukları belirlemek için kullanılabilir.
Uygulama Örnekleri:
- Sosyal Ağ Analizi: Sosyal medya platformlarında kullanıcı gruplarının tespiti, ilgi alanlarına göre toplulukların belirlenmesinde kullanılabilir.
- Bilimsel İşbirliği Ağları: Bilimsel yayınlarda yazarların işbirliği ağlarını analiz ederek, ortak araştırma alanlarına göre grupların belirlenmesi.
- Protein-Protein Etkileşim Ağları: Biyolojik ağlarda, fonksiyonel modüllerin veya protein komplekslerinin tespiti için kullanılır.
Topluluk tespiti, ağın iç yapısını derinlemesine anlamak ve stratejik analizler yapmak için kritik bir araçtır.
")
),
mainPanel(
visNetworkOutput("community_plot", width = "100%", height = "750px") # Plot output
)
)
),
tabPanel("Network Motifs-FANMOD",
sidebarLayout(
sidebarPanel(
fileInput("motif_input", "Choose Data File", accept = c(".csv", ".xlsx", ".xls")),
uiOutput("motif_column_select"), # UI for selecting columns
actionButton("calculate_motifs", "Detect Motifs"),
HTML("
Ağ Motifleri-FANMOD Bölümü
Ağ motifleri, karmaşık ağ yapılarında tekrar eden ve istatistiksel olarak önemli alt graf yapılarını tanımlar. Bu bölüm, ağ veri dosyalarını analiz ederek, motifleri tespit etme ve görselleştirme işlemlerini kolaylaştırır.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
aracılığıyla CSV, XLSX veya XLS formatında ağ veri dosyası yükleyin.
- Sütun Seçimi: Ağın kenarlarını oluşturacak sütunları
uiOutput
ile seçin.
- Motif Tespiti:
actionButton
kullanarak motif tespit işlemini başlatın ve sonuçları görselleştirin.
Anlam ve Kullanım:
Ağ motifleri, ağın temel yapı taşlarını ve ağdaki önemli ilişkileri anlamak için kullanılır. Motif tespiti, ağın yapısal özelliklerini ve ağ içindeki etkileşimleri ortaya çıkarır.
Veri Bilimi Kullanımı:
Biyo-informatik, sosyal ağ analizi, nörobilim ve ekolojik ağlar gibi alanlarda ağ motifleri önemli bir araştırma aracıdır. Ağın fonksiyonel özelliklerini ve ağ içindeki önemli düğüm gruplarını tanımlamada kullanılır.
Desteklenen Dosya Tipleri:
CSV, XLSX ve XLS dosya formatları desteklenmektedir.
Sonuçların Yorumlanması:
Motif tespiti sonuçları, ağ içindeki tekrar eden yapısal desenleri ve bu desenlerin ağın genel yapısı üzerindeki etkilerini gösterir. Tespit edilen motifler, ağın temel işlevsel birimleri olarak yorumlanabilir.
Uygulama Örnekleri:
- Protein Etkileşim Ağları: Biyolojik ağlarda, protein etkileşimlerindeki motifler, biyolojik süreçlerin ve hücresel işlevlerin anlaşılmasına yardımcı olur.
- Sosyal Ağlar: Sosyal ağlarda, bireyler arasındaki etkileşim desenlerini anlamak ve sosyal grupların nasıl oluştuğunu gözlemlemek için motif analizi kullanılır.
- Ekolojik Ağlar: Ekosistemlerdeki türler arası etkileşimlerdeki motifler, ekosistemlerin yapısal ve işlevsel özelliklerini anlamada önemli rol oynar.
Ağ motifleri analizi, ağ yapısını ve dinamiklerini derinlemesine anlamak için güçlü bir araçtır.
")
),
mainPanel(
visNetworkOutput("motif_plot", width = "100%", height = "750px") # Plot output
)
)
),
tabPanel("Network Measures",
tabsetPanel(
tabPanel("Density",
sidebarLayout(
sidebarPanel(
fileInput("dennet_input", "Choose Data File", accept = c(".csv", ".xlsx", ".xls")),
actionButton("calculate_density", "Calculate Network Density"),
HTML("
Ağ Ölçütleri Bölümü
Ağ ölçütleri, bir ağın yapısal özelliklerini nicel olarak ifade eder ve ağın karmaşıklığını, bağlantı yoğunluğunu ve düğümler arasındaki ilişkilerin gücünü analiz etmekte kullanılır.
Yoğunluk:
Yoğunluk, ağdaki olası bağlantıların gerçekleşme oranını gösterir ve ağın ne kadar sıkı bağlantılı olduğuna dair bilgi verir. Yüksek yoğunluklu ağlar, düğümler arasında yüksek derecede etkileşim olduğunu gösterir.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
ile CSV, XLSX veya XLS formatında ağ veri dosyasını yükleyin.
- Yoğunluk Hesaplama:
Calculate Network Density
butonuna tıklayarak ağın yoğunluğunu hesaplayın ve sonuçları görüntüleyin.
Veri Bilimi ve Ağ Analizi:
Ağ ölçütleri, sosyal ağ analizi, biyolojik ağlar, iletişim ağları ve daha pek çok alanda ağın temel karakteristiklerini anlamak için kullanılır. Yoğunluk, ağın etkileşim düzeyi hakkında önemli bilgiler sağlar.
Yoğunluğun Yorumlanması:
Yoğunluk değeri, ağdaki potansiyel bağlantıların ne kadarının gerçekleştiğini gösterir. Yüksek yoğunluk, düğümler arasında güçlü bağlar olduğunu; düşük yoğunluk ise ağın daha seyrek bağlantılı olduğunu ifade eder.
Uygulama Örnekleri:
- Sosyal Ağlar: Sosyal ağlarda yoğunluk analizi, toplulukların birbiriyle ne kadar sıkı bağlantılı olduğunu gösterir ve sosyal yapıların anlaşılmasında kullanılır.
- Biyolojik Ağlar: Protein-protein etkileşim ağlarının yoğunluk analizi, biyolojik süreçlerdeki etkileşim düzeylerini ve potansiyel işlevsel kümeleri belirlemeye yardımcı olur.
- İletişim Ağları: İnternet ve telefon ağlarının yoğunluk analizi, ağın kapasitesi ve etkileşim düzeyi hakkında bilgi verir ve ağın optimize edilmesi için kullanılır.
Yoğunluk analizi, ağ yapılarını ve etkileşimleri derinlemesine anlamak için kritik bir araçtır ve farklı disiplinlerde uygulama bulur.
")
),
mainPanel(
tabPanel("Density Result", textOutput("network_density")),
tabPanel("Density Plot", visNetworkOutput("dennet_plot", width = "100%", height = "750px"))
)
)
),
tabPanel("Clustering Coefficient",
sidebarLayout(
sidebarPanel(
fileInput("cluco_input", "Choose Data File", accept = c(".csv", ".xlsx", ".xls")),
actionButton("calculate_clustering", "Calculate Clustering Coefficient"),
HTML("
Kümeleme Katsayısı Bölümü
Kümeleme katsayısı, bir ağdaki düğümlerin birbirleriyle ne kadar sıkı gruplandığını ölçer ve ağın lokal yoğunluğu hakkında bilgi verir. Bu ölçüt, düğümlerin birbirleriyle olan bağlantılarının ne kadar kümelenmiş olduğunu gösterir.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
ile CSV, XLSX veya XLS formatında ağ veri dosyasını yükleyin.
- Kümeleme Katsayısı Hesaplama:
Calculate Clustering Coefficient
butonuna tıklayarak kümeleme katsayısını hesaplayın ve sonuçları görüntüleyin.
Ağ Analizi ve Veri Bilimi:
Kümeleme katsayısı analizi, sosyal ağlar, biyolojik ağlar ve iletişim ağları gibi çeşitli alanlarda ağın lokal yapısal özelliklerini değerlendirmek için kullanılır. Yüksek bir kümeleme katsayısı, ağın belli bölgelerinde yoğun bağlantılar olduğunu gösterir.
Kümeleme Katsayısının Yorumlanması:
Kümeleme katsayısı değeri, düğümlerin birbirleriyle ne kadar sıkı bir şekilde gruplandığını ifade eder. Yüksek bir değer, ağın belli kısımlarında yoğun bir şekilde bağlantılı düğümler grubu olduğunu; düşük bir değer ise ağın daha seyrek bağlantılı olduğunu gösterir.
Uygulama Alanları:
- Sosyal Ağ Analizi: Sosyal ağlardaki kümeleme katsayısı analizi, insanların birbirleriyle nasıl gruplandığını ve sosyal yapıların nasıl oluştuğunu anlamak için kullanılır.
- Biyolojik Ağlar: Biyolojik ağlarda kümeleme katsayısı, proteinlerin veya genlerin işlevsel gruplarını belirlemek için önemli bir araçtır.
- İletişim Ağları: İnternet ve telefon ağlarında kümeleme katsayısı, ağın yoğun kullanım bölgelerini ve potansiyel zayıf noktaları belirlemeye yardımcı olur.
Kümeleme katsayısı analizi, ağın lokal yapısal özelliklerini anlamak ve ağdaki grupların veya kümelerin nasıl oluştuğunu değerlendirmek için kritik bir araçtır.
")
),
mainPanel(
tabPanel("Clustering Coefficient Result", textOutput("clustering_coefficient")),
tabPanel("Clustering Coefficient Plot", visNetworkOutput("network_clustering_plot", width = "100%", height = "750px"))
)
)
),
tabPanel("Average Path Length",
sidebarLayout(
sidebarPanel(
fileInput("apl_input", "Choose Data File", accept = c(".csv", ".xlsx", ".xls")),
actionButton("calculate_path_length", "Calculate Average Path Length"),
HTML("
Ortalama Yol Uzunluğu Bölümü
Ortalama yol uzunluğu, ağdaki düğümler arasındaki ortalama en kısa yolun uzunluğunu ölçer ve ağın ne kadar sıkı veya dağınık olduğuna dair bilgi verir.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
ile CSV, XLSX veya XLS formatında veri dosyası yükleyin.
- Ortalama Yol Uzunluğu Hesaplama:
Calculate Average Path Length
butonuna tıklayarak ortalama yol uzunluğunu hesaplayın ve sonuçları görüntüleyin.
Ağ Analizi ve Veri Bilimi:
Ortalama yol uzunluğu analizi, iletişim ağlarında veri iletimi etkinliğini, sosyal ağlarda bilgi yayılımını ve biyolojik ağlarda etkileşimlerin kapsamını değerlendirmek için kullanılır.
Ortalama Yol Uzunluğunun Yorumlanması:
Ortalama yol uzunluğu değeri, ağın düğümleri arasındaki etkileşimlerin ne kadar verimli olduğunu gösterir. Düşük bir değer, ağın yoğun ve etkili bir şekilde bağlantılı olduğunu; yüksek bir değer ise ağın daha az bağlantılı ve dağınık olduğunu işaret eder.
Uygulama Alanları:
- İletişim Ağları: İletişim ağlarında ortalama yol uzunluğu analizi, veri iletimi ve sinyal yayılımının etkinliğini ölçmede kullanılır.
- Sosyal Ağ Analizi: Sosyal ağlardaki ortalama yol uzunluğu, bireyler arası etkileşimlerin ve bilgi yayılımının hızını değerlendirmek için önemlidir.
- Biyolojik Ağlar: Biyolojik ağlardaki ortalama yol uzunluğu, proteinler veya genler arasındaki etkileşimlerin verimliliğini ve biyolojik süreçlerin karmaşıklığını gösterir.
Ortalama yol uzunluğu analizi, ağın genel yapısını ve düğümler arasındaki etkileşimlerin etkinliğini değerlendirmek için kritik bir metriktir.
")
),
mainPanel(
tabPanel("Path Length Result", textOutput("average_path_length")),
tabPanel("Path Length Plot", visNetworkOutput("network_path_plot", width = "100%", height = "750px"))
)
)
),
tabPanel("Network Diameter",
sidebarLayout(
sidebarPanel(
fileInput("nd_input", "Choose Data File", accept = c(".csv", ".xlsx", ".xls")),
actionButton("calculate_diameter", "Calculate Network Diameter"),
HTML("
Ağ Çapı Bölümü
Ağ çapı, ağdaki en uzun en kısa yoldur ve ağın yayılımını ölçer. Bu metrik, ağın genişliğini ve düğümler arasındaki potansiyel iletişim mesafesini temsil eder.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
aracılığıyla CSV, XLSX veya XLS formatında bir veri dosyası yükleyin.
- Ağ Çapı Hesaplama:
Calculate Network Diameter
butonuna basarak ağın çapını hesaplayın ve sonuçları görüntüleyin.
Ağ Analizi ve Veri Bilimi:
Ağ çapı, ağın yapısal özelliklerini anlamada önemli bir metriktir. Ağın karmaşıklığı, bilgi veya hastalık yayılımı hızı gibi faktörler bu değerle ilişkilendirilebilir.
Ağ Çapının Yorumlanması:
Küçük bir ağ çapı değeri, ağın yoğun bir şekilde bağlantılı olduğunu ve bilginin hızlı bir şekilde yayılabileceğini gösterir. Büyük bir ağ çapı değeri ise, ağın daha geniş ve yayılmış olduğunu, bu nedenle bilginin bir uçtan diğerine yayılmasının daha uzun sürebileceğini gösterir.
Uygulama Alanları:
- Sosyal Ağlar: Sosyal ağlarda ağ çapı analizi, bilgi veya trendlerin ne kadar hızla yayılabileceğini anlamak için kullanılır.
- Ulaşım Ağları: Ulaşım ağlarında ağ çapı, ulaşım sistemlerinin verimliliğini ve erişilebilirliğini değerlendirmede yardımcı olur.
- Bilgi Ağları: İnternet gibi bilgi ağlarında ağ çapı, bilginin yayılma hızı ve erişim kolaylığı hakkında fikir verir.
Ağ çapı analizi, ağın yapısal özelliklerini ve düğümler arası en uzak mesafeleri değerlendirmede kritik bir öneme sahiptir.
")
),
mainPanel(
tabPanel("Network Diameter Result", textOutput("network_diameter")),
tabPanel("Network Diameter Plot", visNetworkOutput("network_diameter_plot", width = "100%", height = "750px"))
)
)
)
)
),
tabPanel("Random Network Models",
tabsetPanel(
tabPanel("Configuration Model",
sidebarLayout(
sidebarPanel(
fileInput('conmodelfile', 'Choose Your File', accept = c('.csv', '.xlsx', '.xsx')),
uiOutput("columnSelectSource"), # Dynamic UI for selecting source column
uiOutput("columnSelectTarget"), # Dynamic UI for selecting target column
radioButtons('method', 'Plot Method',
choices = c(simple = 'simple', VigerandLatapy = 'vl', SimpleNoMultiple = 'simple.no.multiple', SimpleNoMultipleUniform = "simple.no.multiple.uniform"),
selected = 'simple'),
actionButton("generateconmodel", "Configuration Model"),
HTML("
Yapılandırma Modeli Bölümü
Yapılandırma modeli, ağ yapısını anlamak ve rastgele ağlar oluşturmak için kullanılan bir yöntemdir. Bu model, düğümlerin derece dağılımını koruyarak, ağın rastgele bir versiyonunu oluşturur.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
aracılığıyla CSV, XLSX veya XLS formatında bir veri dosyası yükleyin.
- Kaynak ve Hedef Sütun Seçimi: Dinamik olarak oluşturulan UI'dan kaynak ve hedef sütunlarını seçin.
- Yapılandırma Modeli Oluşturma:
Configuration Model
butonuna basarak modeli oluşturun ve ağ görselleştirmesini görüntüleyin.
Yapılandırma Modelinin Anlamı:
Yapılandırma modeli, özgün ağın derece dağılımını koruyarak, ağın rastgele bir versiyonunu oluşturur. Bu, ağın topolojik özelliklerini ve rastgelelik düzeylerini analiz etmek için faydalıdır.
Ağ Analizi ve Veri Bilimi:
Yapılandırma modeli, sosyal ağlar, biyolojik ağlar ve teknoloji ağları gibi çeşitli ağ türlerinin yapısal özelliklerini anlamada kullanılır. Bu model, ağın özelliklerini rastgele ağlarla karşılaştırmak için temel bir araçtır.
Uygulama Alanları:
- Sosyal Ağ Analizi: Yapılandırma modeli, sosyal ilişkilerin rastgele mi yoksa anlamlı mı olduğunu belirlemek için kullanılabilir.
- Biyolojik Ağlar: Biyolojik ağlarda, yapılandırma modeli, protein etkileşimleri gibi süreçlerin rastgele mi yoksa işlevsel mi olduğunu anlamada kullanılır.
- Teknoloji ve Bilgi Ağları: İnternet gibi teknoloji ağlarında, yapılandırma modeli, ağın dayanıklılığını ve bilgi yayılımını değerlendirmek için kullanılabilir.
Yapılandırma modeli, ağların rastgelelik ve yapısal özelliklerini anlamak için güçlü bir araçtır.
")
),
mainPanel(
visNetworkOutput("networkVisualization", width = "100%", height = "750px")
)
)
),
tabPanel("Small World Model",
sidebarLayout(
sidebarPanel(
fileInput('smallworldfile', 'Choose Your File', accept = c('.csv', '.xlsx', '.xsx')),
uiOutput("sourceswl"), # Dynamic UI for selecting source column
numericInput('num_nodes', 'Number of nodes', value = 20, min = 3),
numericInput('nei', 'Each node is connected to `nei` neighbors', value = 2, min = 1),
sliderInput('prob', 'Probability of rewiring each edge', min = 0, max = 1, value = 0.1),
actionButton("generatesmallworld", "Generate Small-World Model"),
HTML("
Küçük Dünya Modeli Bölümü
Küçük dünya modeli, ağların 'küçük dünya' özelliklerini incelemek için kullanılan bir yöntemdir. Bu model, düğümlerin birkaç adımda birbirine ulaşabildiği yoğun olarak bağlantılı ağlar oluşturur.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
aracılığıyla CSV, XLSX veya XLS formatında bir veri dosyası yükleyin.
- Parametre Girişleri: Ağdaki düğüm sayısı, her düğümün kaç komşu ile bağlı olduğu ve kenarların yeniden bağlanma olasılığı gibi parametreleri girin.
- Küçük Dünya Modeli Oluşturma:
Generate Small-World Model
butonuna basarak modeli oluşturun ve ağ görselleştirmesini görüntüleyin.
Küçük Dünya Modelinin Anlamı:
Küçük dünya modeli, düğümler arasındaki ortalama mesafenin küçük olduğu, ancak yerel kümelenme katsayısının yüksek olduğu ağlar oluşturur. Bu, birçok gerçek dünya ağının karakteristiğidir.
Ağ Analizi ve Veri Bilimi:
Küçük dünya modeli, sosyal ağlar, bilimsel işbirliği ağları ve beyin ağları gibi çeşitli ağ türlerinde görülen 'altı derece ayırma' fenomenini anlamada kullanılır.
Uygulama Alanları:
- Sosyal Ağ Analizi: Küçük dünya modeli, sosyal ağların verimli bilgi yayılımını ve etkileşimi nasıl sağladığını anlamada kullanılır.
- Bilim ve Araştırma: Bilimsel işbirliği ağlarının küçük dünya özellikleri, bilgi akışı ve işbirliğinin yapısal dinamiklerini açıklamada önemlidir.
- Bilgi ve İletişim Teknolojileri: İnternet ve diğer iletişim ağlarının küçük dünya özellikleri, ağın verimliliğini ve dayanıklılığını anlamak için incelenir.
Küçük dünya modeli, ağların karmaşık yapılarını ve dinamiklerini anlamak için temel bir araçtır.
")
),
mainPanel(
visNetworkOutput("smallworldnetwork", width = "100%", height = "750px")
)
)
),
tabPanel("Scale-Free Model",
sidebarLayout(
sidebarPanel(
fileInput('scalefreefile', 'Choose Your File', accept = c('.csv', '.xlsx')),
numericInput('init_nodes', 'Initial number of nodes', value = 3, min = 1),
numericInput('m', 'Number of edges to attach from a new node to existing nodes', value = 1, min = 1),
actionButton("generatescalefree", "Generate Scale-Free Model"),
HTML("
Ölçeksiz Model Bölümü
Ölçeksiz model, birçok gerçek dünya ağının izlediği güç yasası bağlantı dağılımını taklit eden ağlar oluşturmak için kullanılır. Bu model, bazı düğümlerin çok daha fazla bağlantıya sahip olduğu 'hub'ları veya 'merkezi düğümleri' yansıtır.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
aracılığıyla CSV veya XLSX formatında bir veri dosyası yükleyin.
- Parametre Girişleri: Başlangıçtaki düğüm sayısı, yeni bir düğümün mevcut düğümlere bağlanırken ekleyeceği kenar sayısı gibi parametreleri girin.
- Ölçeksiz Model Oluşturma:
Generate Scale-Free Model
butonuna basarak modeli oluşturun ve ağ görselleştirmesini görüntüleyin.
Ölçeksiz Modelin Anlamı:
Ölçeksiz model, ağlardaki düğümlerin bağlantı sayısının güç yasası dağılımını takip ettiğini varsayar. Yani, az sayıda düğümün çok sayıda bağlantısı vardırken, çoğu düğümün az sayıda bağlantısı vardır.
Ağ Analizi ve Veri Bilimi:
Ölçeksiz model, internet, sosyal ağlar ve protein etkileşim ağları gibi çeşitli ağ türlerinin yapısını anlamada kullanılır.
Uygulama Alanları:
- Sosyal Ağ Analizi: Ölçeksiz model, sosyal ağların nasıl büyüdüğünü ve bilginin nasıl yayıldığını anlamada kullanılır.
- Bilim ve Araştırma: Bilim adamları, ölçeksiz modeli, doğal ve yapay sistemlerdeki ağ yapılarını araştırmak için kullanır.
- Bilgi ve İletişim Teknolojileri: İnternetin yapısını ve dayanıklılığını anlamak için ölçeksiz modelleme teknikleri kullanılır.
Ölçeksiz model, karmaşık ağ yapılarını ve bunların nasıl geliştiğini anlamada önemli bir araçtır.
")
),
mainPanel(
visNetworkOutput("scalefreenetwork", width = "100%", height = "750px")
)
)
),
tabPanel("Preferential Attachment Model",
sidebarLayout(
sidebarPanel(
fileInput('palmofile', 'Choose Your Data File', accept = c('.csv', '.xlsx')),
numericInput('num_nodes', 'Number of nodes', value = 100, min = 1),
actionButton('genpalmo', 'Generate Network'),
HTML("
Tercihli Bağlanma Modeli Bölümü
Tercihli Bağlanma Modeli, ağların zamanla nasıl büyüdüğünü ve geliştiğini modellemek için kullanılır. Bu model, yeni düğümlerin var olan yüksek dereceli düğümlere tercihli olarak bağlandığı varsayımına dayanır.
Kullanım Adımları:
- Veri Dosyası Yükleme:
fileInput
aracılığıyla CSV veya XLSX formatında bir veri dosyası yükleyin.
- Düğüm Sayısı Girişi:
numericInput
ile ağınızda olmasını istediğiniz düğüm sayısını girin.
- Ağ Oluşturma:
Generate Network
butonuna tıklayarak tercihli bağlanma modeline dayalı bir ağ oluşturun ve görselleştirin.
Tercihli Bağlanma Modelinin Anlamı:
Yeni düğümlerin, var olan düğümlere, var olan bağlantı sayısına orantılı olarak bağlanma eğilimi gösterdiği bir büyüme modelidir. Bu, -zengin daha zengin olur- prensibini yansıtır ve birkaç düğümün ağın büyük bir kısmıyla bağlantılı olabileceği karmaşık ağ yapılarını açıklar.
Ağ Analizi ve Veri Bilimi:
Tercihli Bağlanma Modeli, sosyal ağ analizi, biyolojik ağlar ve internet gibi alanlarda kullanılmaktadır.
Uygulama Alanları:
- Sosyal Ağlar: Sosyal ağlardaki popüler kullanıcıların nasıl daha fazla takipçi kazandığını açıklamak için kullanılır.
- Bilimsel İşbirlikleri: Bilim adamları arasındaki işbirliği ağlarının büyüme dinamiklerini modellemek için kullanılır.
- Altyapı Ağları: İnternet gibi teknolojik ağların büyüme ve evrimini anlamak için kullanılır.
Tercihli Bağlanma Modeli, ağların evrimini ve büyümesini anlamada önemli bir araçtır ve çeşitli disiplinlerde uygulama bulmaktadır.
")
),
mainPanel(
visNetworkOutput("palmoPlot", width = "100%", height = "750px")
)
)
)
)
)
)
)
server <- function(input, output, session) {
##Social Network Analysis
###Degree Centrality
# Function to read the uploaded file (csv, xlsx)
read_uploaded_file <- function(filepath) {
if (grepl("\\.csv$", filepath)) {
return(read.csv(filepath, stringsAsFactors = FALSE))
} else if (grepl("\\.(xlsx|xls)$", filepath)) {
return(readxl::read_excel(filepath))
} else {
stop("Unsupported file type")
}
}
# Reactive values to store the combined dataframe and the graph
graph_data <- reactiveVal()
# Observer for file input
observeEvent(input$dcent_input, {
req(input$dcent_input)
# Read and combine all uploaded files
all_data <- lapply(input$dcent_input$datapath, read_uploaded_file)
combined_data <- do.call(rbind, all_data)
# Update the graph_data reactive value
graph_data(combined_data)
# Dynamic UI for column selection
output$target_dcent1 <- renderUI({
req(combined_data)
selectInput("tcoldeg1", "Select the first entity column", choices = names(combined_data))
})
output$target_dcent2 <- renderUI({
req(combined_data)
selectInput("tcoldeg2", "Select the second entity column", choices = names(combined_data))
})
})
# Observer for processing the degree centrality
observeEvent(input$degree_cent_sna, {
req(input$dcent_input, input$tcoldeg1, input$tcoldeg2)
# Extract the edge list from the selected columns
edges_df <- graph_data() %>%
dplyr::select(input$tcoldeg1, input$tcoldeg2) %>% # Use !! for dynamic column names
distinct()
# Check if the edge list is valid
if (ncol(edges_df) != 2) {
output$dcent_sna_plot <- renderPrint({
"The edge list must have exactly two columns."
})
return()
}
# Create a graph from the edge list
g <- graph_from_data_frame(edges_df, directed = FALSE)
# Calculate degree centrality
degree_cent <- igraph::degree(g, mode = "all")
V(g)$degree <- degree_cent
# Generate the network plot
output$dcent_sna_plot <- renderVisNetwork({
nodes <- data.frame(id = V(g)$name, label = V(g)$name, value = V(g)$degree)
edges <- data.frame(from = as_edgelist(g), to = as_edgelist(g))
visNetwork(nodes, edges) %>%
visNodes(value = "value") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE) %>%
visLegend()
})
})
###Betweenness Centrality
# Function to read the uploaded file (csv, xlsx)
graph_data <- reactiveVal(NULL)
# Function to read the uploaded file
read_uploaded_fbc <- reactive({
req(input$bc_input)
ext <- tools::file_ext(input$bc_input$datapath)
switch(ext,
"csv" = read.csv(input$bc_input$datapath, stringsAsFactors = FALSE),
"xlsx" = readxl::read_excel(input$bc_input$datapath),
"xsx" = readxl::read_excel(input$bc_input$datapath),
stop("Unsupported file type"))
})
# UI output for dynamic column selection
output$bc_target <- renderUI({
# Assuming 'read_uploaded_fbc()' returns the uploaded data
df <- read_uploaded_fbc()
if (!is.null(df)) {
selectInput("bc_vars", "Select variables", choices = names(df), multiple = TRUE)
}
})
# Observer for calculating betweenness centrality
observeEvent(input$bc_calculate, {
req(input$bc_input, input$bc_vars) # Ensure file and variables are selected
df <- read_uploaded_fbc() # Get the uploaded data
selected_vars <- input$bc_vars # Get the selected variables
# Check that two variables are selected for creating an edge list
if (length(selected_vars) == 2) {
# Create the graph using the selected variables as edges
edges <- df %>% dplyr::select(all_of(selected_vars)) %>% distinct()
g <- graph_from_data_frame(edges, directed = FALSE)
# Calculate betweenness centrality
bc <- igraph::betweenness(g, directed = FALSE)
V(g)$betweenness <- bc
# Prepare the data for visNetwork
nodes <- data.frame(id = V(g)$name, label = V(g)$name, value = V(g)$betweenness)
edges_df <- get.data.frame(g, what = "edges")
# Render the network plot
output$bc_plot <- renderVisNetwork({
visNetwork(nodes, edges_df) %>%
visNodes(value = "value") %>%
visEdges(arrows = "to") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE) %>%
visLegend()
})
} else {
# Output a message if the selection is not correct
output$bc_plot <- renderPrint({
"Please select exactly two variables to create an edge list for the network."
})
}
})
###Closeness Centrality
# Reactive expression to read the uploaded file
read_uploaded_fcc <- reactive({
req(input$cc_input)
ext <- tools::file_ext(input$cc_input$datapath)
switch(ext,
"csv" = read.csv(input$cc_input$datapath, stringsAsFactors = FALSE),
"xlsx" = readxl::read_excel(input$cc_input$datapath),
stop("Unsupported file type"))
})
# Dynamic UI for column selection
output$cc_target <- renderUI({
df <- read_uploaded_fcc()
selectInput("cc_vars", "Select variables", choices = names(df), multiple = TRUE)
})
# Observer for calculating closeness centrality
observeEvent(input$cc_calculate, {
req(input$cc_input)
df <- read_uploaded_fcc()
selected_vars <- input$cc_vars
# Check that two variables are selected for creating an edge list
if (length(selected_vars) == 2) {
# Create the graph using the selected variables as edges
edges <- df %>% dplyr::select(all_of(selected_vars)) %>% distinct()
g <- graph_from_data_frame(edges, directed = FALSE)
# Calculate closeness centrality
cc <- igraph::closeness(g, mode = "all")
V(g)$closeness <- cc
# Generate the network plot
output$cc_plot <- renderVisNetwork({
nodes <- data.frame(id = V(g)$name, label = V(g)$name, value = V(g)$closeness)
edges_df <- get.data.frame(g, what = "edge")
visNetwork(nodes, edges_df) %>%
visNodes(value = "value", color = "darkorange") %>%
visEdges(arrows = "to") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE) %>%
visLegend()
})
} else {
# Output a message if the selection is not correct
output$cc_plot <- renderPrint({
"Please select exactly two variables to create an edge list for the network."
})
}
})
###Eigenvector Centrality
# Helper functions
read_uploaded_file <- function(filepath) {
ext <- tools::file_ext(filepath)
if (ext == "csv") {
return(read.csv(filepath, stringsAsFactors = FALSE))
} else if (ext %in% c("xlsx", "xls")) {
return(readxl::read_excel(filepath))
} else {
stop("Unsupported file type")
}
}
# Reactive value for combined data
combined_data <- reactiveVal(data.frame())
# Observe file input and update UI for column selection
observeEvent(input$eigen_input, {
req(input$eigen_input)
all_data <- lapply(input$eigen_input$datapath, read_uploaded_file)
combined <- do.call(rbind, all_data)
combined_data(combined)
output$eigen_column_select <- renderUI({
req(combined_data())
selectInput("selected_columns", "Select Columns", choices = names(combined_data()), multiple = TRUE)
})
})
# Observe button click to calculate centrality
observeEvent(input$calculate_eigen, {
req(combined_data(), input$selected_columns)
# Create edge list from selected columns
df <- combined_data()
selected <- df[, input$selected_columns]
# Ensure we have a proper edge list
if (ncol(selected) < 2) {
showModal(modalDialog(
title = "Error",
"Please select at least two columns for the analysis."
))
return()
}
# Convert to edge list if necessary and create a graph object
g <- graph_from_data_frame(selected, directed = FALSE)
# Calculate Eigenvector Centrality
eigen_cent <- eigen_centrality(g)$vector
V(g)$eigen <- eigen_cent
# Prepare data for visualization
nodes <- data.frame(id = V(g)$name, label = V(g)$name, value = V(g)$eigen)
edges <- data.frame(from = as_edgelist(g)[, 1], to = as_edgelist(g)[, 2])
# Render the network plot
output$eigen_plot <- renderVisNetwork({
visNetwork(nodes, edges) %>%
visNodes(value = "value") %>% # Node size based on centrality
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE) %>%
visLegend()
})
})
###Community Detection
#Helper Function
read_uploaded_file <- function(filepath) {
ext <- tools::file_ext(filepath)
if (ext == "csv") {
return(read.csv(filepath, stringsAsFactors = FALSE))
} else if (ext %in% c("xlsx", "xls")) {
return(readxl::read_excel(filepath))
} else {
stop("Unsupported file type")
}
}
# Reactive value for combined data
combined_data <- reactiveVal(data.frame())
# Observe file input and update UI for column selection
observeEvent(input$community_input, {
req(input$community_input)
all_data <- lapply(input$community_input$datapath, read_uploaded_file)
combined <- do.call(rbind, all_data)
combined_data(combined)
output$community_column_select <- renderUI({
req(combined_data())
selectInput("selected_columns_community", "Select Columns", choices = names(combined_data()), multiple = TRUE)
})
})
# Observe button click to calculate community detection
observeEvent(input$calculate_community, {
req(combined_data(), input$selected_columns_community)
# Create edge list from selected columns
df <- combined_data()
selected <- df[, input$selected_columns_community]
# Ensure we have a proper edge list
if (ncol(selected) < 2) {
showModal(modalDialog(
title = "Error",
"Please select at least two columns for the analysis."
))
return()
}
# Convert to edge list if necessary and create a graph object
g <- graph_from_data_frame(selected, directed = FALSE)
# Apply community detection algorithm
community <- cluster_louvain(g)
membership <- membership(community)
V(g)$community <- membership
# Prepare data for visualization
nodes <- data.frame(id = V(g)$name, label = V(g)$name, group = V(g)$community)
edges <- data.frame(from = get.edgelist(g)[, 1], to = get.edgelist(g)[, 2])
# Render the network plot
output$community_plot <- renderVisNetwork({
visNetwork(nodes, edges) %>%
visNodes(group = "group") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE) %>%
visGroups(groupname = "community", options = list(shape = "dot", color = "#FFC0CB")) %>%
visLegend()
})
})
###Network Motifs
# Function to read the uploaded file
read_uploaded_file <- function(filepath) {
ext <- tools::file_ext(filepath)
if (ext == "csv") {
return(read.csv(filepath, stringsAsFactors = FALSE))
} else if (ext %in% c("xlsx", "xls")) {
return(readxl::read_excel(filepath))
} else {
stop("Unsupported file type")
}
}
# Reactive value for combined data
combined_data <- reactiveVal(data.frame())
# Observe file input and update UI for column selection
observeEvent(input$motif_input, {
req(input$motif_input)
all_data <- lapply(input$motif_input$datapath, read_uploaded_file)
combined <- do.call(rbind, all_data)
combined_data(combined)
output$motif_column_select <- renderUI({
req(combined_data())
selectInput("selected_columns_motif", "Select Columns", choices = names(combined_data()), multiple = TRUE)
})
})
# Observe button click to calculate network motifs
observeEvent(input$calculate_motifs, {
req(combined_data(), input$selected_columns_motif)
# Create edge list from selected columns
df <- combined_data()
selected <- df[, input$selected_columns_motif]
# Ensure we have a proper edge list
if (ncol(selected) < 2) {
showModal(modalDialog(
title = "Error",
"Please select at least two columns for the analysis."
))
return()
}
# Convert to edge list if necessary and create a graph object
g <- graph_from_data_frame(selected, directed = FALSE)
# Apply motif detection algorithm (placeholder, replace with actual motif detection logic)
motif_results <- detect_motifs(g)
motifs <- motif_results$motifs
# Prepare data for visualization (adjust based on motif detection output)
nodes <- data.frame(id = V(g)$name, label = V(g)$name)
edges <- data.frame(from = as_edgelist(g)[, 1], to = as_edgelist(g)[, 2])
# Render the network plot with motifs highlighted
output$motif_plot <- renderVisNetwork({
visNetwork(nodes, edges) %>%
visNodes() %>%
visEdges(arrows = "to") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE) %>%
visLegend()
# Use additional visNetwork settings to highlight motifs
})
})
# Helper function for motif detection (this is a placeholder, replace with actual logic)
detect_motifs <- function(graph) {
# Detect motifs in the graph
# This would be replaced with the actual function and package you plan to use for motif detection
# For example, you might use the FANMOD algorithm or another method.
# Ensure the function returns a list with at least a 'motifs' component
motifs <- list() # Placeholder, replace with actual motifs
return(list(motifs = motifs))
}
###Network Measures
####Density
# Function to read uploaded file
read_uploaded_dennet <- reactive({
req(input$dennet_input)
ext <- tools::file_ext(input$dennet_input$name)
switch(ext,
csv = read.csv(input$dennet_input$datapath, stringsAsFactors = FALSE),
xls = readxl::read_excel(input$dennet_input$datapath),
xlsx = readxl::read_excel(input$dennet_input$datapath),
stop("Unsupported file type"))
})
observeEvent(input$calculate_density, {
req(input$dennet_input)
df <- read_uploaded_dennet()
# Assuming the uploaded file is an edge list with two columns
# Adjust this part if your data has a different format
if (ncol(df) != 2) {
showModal(modalDialog(
title = "Error",
"Uploaded data must have exactly two columns for an edge list."
))
return()
}
# Create graph from edge list
g <- graph_from_data_frame(df, directed = FALSE)
# Calculate network density
density_val <- igraph::edge_density(g)
# Display density
output$network_density <- renderText({
paste("Network Density:", density_val)
})
# Generate and display the network plot
output$dennet_plot <- renderVisNetwork({
nodes <- data.frame(id = V(g)$name, label = V(g)$name)
edges <- data.frame(from = as_edgelist(g)[, 1], to = as_edgelist(g)[, 2])
visNetwork(nodes, edges) %>%
visEdges(arrows = "to") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE)
})
})
####Clustering Coefficient
# Function to read uploaded file
read_uploaded_cluco <- reactive({
req(input$cluco_input)
ext <- tools::file_ext(input$cluco_input$name)
switch(ext,
csv = read.csv(input$cluco_input$datapath, stringsAsFactors = FALSE),
xls = readxl::read_excel(input$cluco_input$datapath),
xlsx = readxl::read_excel(input$cluco_input$datapath),
stop("Unsupported file type"))
})
observeEvent(input$calculate_clustering, {
req(input$cluco_input)
df <- read_uploaded_cluco()
# Assuming the uploaded file is an edge list with two columns
if (ncol(df) != 2) {
showModal(modalDialog(
title = "Error",
"Uploaded data must have exactly two columns for an edge list."
))
return()
}
# Create graph from edge list
g <- graph_from_data_frame(df, directed = FALSE)
# Calculate clustering coefficient
clustering_val <- transitivity(g, type = "average")
# Display clustering coefficient
output$clustering_coefficient <- renderText({
paste("Average Clustering Coefficient:", clustering_val)
})
# Generate and display the network plot
output$network_clustering_plot <- renderVisNetwork({
nodes <- data.frame(id = V(g)$name, label = V(g)$name)
edges <- data.frame(from = get.edgelist(g)[, 1], to = get.edgelist(g)[, 2])
visNetwork(nodes, edges) %>%
visEdges(arrows = "to") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE)
})
})
####Average Path Length
# Function to read uploaded file
read_uploaded_apl <- reactive({
req(input$apl_input)
ext <- tools::file_ext(input$apl_input$name)
switch(ext,
csv = read.csv(input$apl_input$datapath, stringsAsFactors = FALSE),
xls = readxl::read_excel(input$apl_input$datapath),
xlsx = readxl::read_excel(input$apl_input$datapath),
stop("Unsupported file type"))
})
observeEvent(input$calculate_path_length, {
req(input$apl_input)
df <- read_uploaded_apl()
# Assuming the uploaded file is an edge list with two columns
if (ncol(df) != 2) {
showModal(modalDialog(
title = "Error",
"Uploaded data must have exactly two columns for an edge list."
))
return()
}
# Create graph from edge list
g <- graph_from_data_frame(df, directed = FALSE)
# Calculate average path length
paths <- distances(g)
avg_path_length <- mean(paths[upper.tri(paths)])
# Display average path length
output$average_path_length <- renderText({
paste("Average Path Length:", avg_path_length)
})
# Generate and display the network plot with highlighted shortest paths (if feasible)
output$network_path_plot <- renderVisNetwork({
nodes <- data.frame(id = V(g)$name, label = V(g)$name)
edges <- data.frame(from = get.edgelist(g)[, 1], to = get.edgelist(g)[, 2])
visNetwork(nodes, edges) %>%
visEdges(arrows = "to") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE)
})
})
####Network Diameter
# Function to read uploaded file
read_uploaded_nd <- reactive({
req(input$nd_input)
ext <- tools::file_ext(input$nd_input$name)
switch(ext,
csv = read.csv(input$nd_input$datapath, stringsAsFactors = FALSE),
xls = readxl::read_excel(input$nd_input$datapath),
xlsx = readxl::read_excel(input$nd_input$datapath),
stop("Unsupported file type"))
})
observeEvent(input$calculate_diameter, {
req(input$nd_input)
df <- read_uploaded_nd()
# Assuming the uploaded file is an edge list with two columns
if (ncol(df) != 2) {
showModal(modalDialog(
title = "Error",
"Uploaded data must have exactly two columns for an edge list."
))
return()
}
# Create graph from edge list
g <- graph_from_data_frame(df, directed = FALSE)
# Calculate network diameter
diameter_value <- diameter(g, directed = FALSE, unconnected = TRUE)
# Display network diameter
output$network_diameter <- renderText({
paste("Network Diameter:", diameter_value)
})
# Generate and display the network plot
output$network_diameter_plot <- renderVisNetwork({
nodes <- data.frame(id = V(g)$name, label = V(g)$name)
edges <- data.frame(from = get.edgelist(g)[, 1], to = get.edgelist(g)[, 2])
visNetwork(nodes, edges) %>%
visEdges(arrows = "to") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE) %>%
visIgraphLayout(layout = "layout_with_fr") %>%
visLegend()
})
})
###Configuration Model
# Function to read the uploaded file
uploadedconmo <- reactive({
req(input$conmodelfile)
ext <- tools::file_ext(input$conmodelfile$name) # Corrected variable name here
switch(ext,
csv = read.csv(input$conmodelfile$datapath, stringsAsFactors = FALSE),
xls = readxl::read_excel(input$conmodelfile$datapath),
xlsx = readxl::read_excel(input$conmodelfile$datapath),
stop("Unsupported file type"))
})
# To populate the selectInput for columns dynamically based on the uploaded file
output$columnSelectSource <- renderUI({
df <- uploadedconmo()
if (is.null(df)) return(NULL)
selectInput("sourceColumn", "Select Source Column", names(df))
})
output$columnSelectTarget <- renderUI({
df <- uploadedconmo()
if (is.null(df)) return(NULL)
selectInput("targetColumn", "Select Target Column", names(df))
})
# Inside your server function
generateconmo <- eventReactive(input$generateconmodel, {
df <- uploadedconmo()
if (is.null(df)) return(NULL)
# Make sure that the user has selected both a source and a target
req(input$sourceColumn, input$targetColumn)
# Subset the dataframe to only include the selected source and target columns
df <- df[, c(input$sourceColumn, input$targetColumn)]
# Now create the graph using the subsetted dataframe
g <- graph_from_data_frame(df, directed = FALSE)
# Explicitly use the degree function from igraph
degree_sequence <- igraph::degree(g)
# Generate the random graph
g_random <- tryCatch({
igraph::sample_degseq(degree_sequence, method = input$method)
}, error = function(e) {
showNotification("Failed to generate a Configuration Model based graph. Please check your data.", type = "error")
return(NULL)
})
return(g_random)
})
output$networkVisualization <- renderVisNetwork({
req(generateconmo())
g_random <- generateconmo()
if (!is.null(g_random) && inherits(g_random, "igraph")) {
visIgraph(g_random)
} else {
visNetwork() # an empty visNetwork object to avoid crashing
}
})
###Small World Model
# Function to read the uploaded file
uploadedswl <- reactive({
req(input$smallworldfile)
ext <- tools::file_ext(input$smallworldfile$name) # Corrected variable name here
switch(ext,
csv = read.csv(input$smallworldfile$datapath, stringsAsFactors = FALSE),
xls = readxl::read_excel(input$smallworldfile$datapath),
xlsx = readxl::read_excel(input$smallworldfile$datapath),
stop("Unsupported file type"))
})
# Server-side adjustments
output$sourceswl <- renderUI({
df <- uploadedswl()
if (is.null(df)) return(NULL)
selectInput("sourceColumn", "Select Source Column", names(df))
})
# Assuming 'sourceColumn' influences a node attribute directly
generateNetwork <- eventReactive(input$generatesmallworld, {
req(input$sourceColumn) # Ensure a source column is selected
df <- uploadedswl()
# Make sure to use the selected column meaningfully
# For example, if the column's data influences the 'num_nodes', adjust logic here
num_nodes <- min(nrow(df), input$num_nodes) # Use the smaller of the two to avoid exceeding data bounds
g <- sample_smallworld(1, num_nodes, input$nei, input$prob)
# Set node attribute from the selected column
# Ensure we're assigning the attribute correctly; this line assumes 'attribute' is the column name
if(!is.null(df[[input$sourceColumn]])) {
V(g)$attribute <- df[1:num_nodes, input$sourceColumn, drop = FALSE]
}
return(g)
})
# Render the Small-World network visualization
output$smallworldnetwork <- renderVisNetwork({
req(generateNetwork())
g <- generateNetwork()
# Setup visualization with visNetwork
visIgraph(g) %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE) %>%
visEdges(arrows = 'to')
})
####Scale-Free Model
uploadedScaleFree <- reactive({
req(input$scalefreefile)
ext <- tools::file_ext(input$scalefreefile$name)
switch(ext,
csv = read.csv(input$scalefreefile$datapath, stringsAsFactors = FALSE),
xlsx = readxl::read_excel(input$scalefreefile$datapath),
stop("Unsupported file type"))
})
generateScaleFreeNetwork <- eventReactive(input$generatescalefree, {
# Parameters can be adjusted based on the uploaded data if needed
df <- uploadedScaleFree()
# Example: Use the number of rows in the data to determine the number of nodes
# This is just an example; adjust according to your actual needs
num_nodes <- nrow(df) + input$init_nodes # Adding initial nodes to the count
g <- sample_pa(n = num_nodes, m = input$m, directed = FALSE)
return(g)
})
output$scalefreenetwork <- renderVisNetwork({
req(generateScaleFreeNetwork())
g <- generateScaleFreeNetwork()
visIgraph(g) %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE) %>%
visEdges(arrows = 'to')
})
####Preferential Attachment Model
datapalmo <- reactive({
req(input$palmofile)
switch(
tools::file_ext(input$palmofile$name),
csv = read.csv(input$palmofile$datapath, stringsAsFactors = FALSE),
xlsx = readxl::read_excel(input$palmofile$datapath),
stop("Unsupported file type")
)
})
observeEvent(input$genpalmo, {
# Example: Use the number of rows in the uploaded data to determine the number of nodes
# This is simplistic and might not be directly applicable depending on your specific needs
df <- datapalmo()
num_nodes <- input$num_nodes
if (nrow(df) < num_nodes) {
num_nodes <- nrow(df)
}
# Generating a Preferential Attachment model network
g <- sample_pa(n = num_nodes, m = 1, directed = FALSE)
# Optional: Use data to add attributes to nodes/edges here
output$palmoPlot <- renderVisNetwork({
visIgraph(g) %>%
visIgraphLayout(layout = "layout_with_fr") %>%
visOptions(highlightNearest = TRUE, nodesIdSelection = TRUE)
})
})
}
shinyApp(ui, server)