Visualizing Text Data: Techniques and Applications

# Install necessary libraries if not already installed
# !pip install wordcloud matplotlib

from wordcloud import WordCloud
import matplotlib.pyplot as plt

# Sample text
text = """
Data visualization is an interdisciplinary field that deals with the graphic representation of data. 
It is a particularly efficient way of communicating when the data is numerous as for example a time series.
Excel's capabilities of managing spreadsheet data through data visualization tools, 
such as conditional formatting and graphing tools, have made it a widely applied data visualization tool.
"""

# Generate the word cloud
wordcloud = WordCloud(width=800, height=400, background_color='white').generate(text)

# Display the word cloud using matplotlib
plt.figure(figsize=(10, 5))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')  # Remove axes
plt.show()

from collections import Counter
import matplotlib.pyplot as plt

# Sample text data
text = "This is a sample text about data visualization. Data visualization is a powerful tool for exploring and understanding data. It helps us see patterns and trends that might be difficult to identify from raw numbers."

# Preprocess the text (lowercase, remove punctuation, split into words)
text = text.lower()
text = "".join([char for char in text if char.isalnum() or char == " "])
words = text.split()

# Remove stop words (optional, adjust stopwords list as needed)
stopwords = ["a", "an", "the", "is", "of", "and", "to", "in", "on", "for", "it", "with", "as", "be", "have", "at", "by", "or", "that", "my", "one", "this", "s", "what", "he", "will", "all", "from", "they", "are", "we", "her", "because", "was", "your", "when", "up", "more", "used"]
words = [word for word in words if word not in stopwords]

# Count word frequencies
word_counts = Counter(words)

# Extract top 10 most frequent words (adjust as needed)
top_10_words = word_counts.most_common(10)
word_labels = [word for word, _ in top_10_words]
word_counts = [count for _, count in top_10_words]

# Create the bar chart
plt.figure(figsize=(8, 6))  # Adjust figure size as desired
plt.bar(word_labels, word_counts)
plt.xlabel("Words")
plt.ylabel("Frequency")
plt.title("Top 10 Most Frequent Words")
plt.xticks(rotation=45, ha="right")  # Rotate x-axis labels for readability
plt.tight_layout()
plt.show()

import networkx as nx
from collections import Counter

# Sample text data
text = "The quick brown fox jumps over the lazy dog. This is another sentence for analysis."

# Preprocess text (lowercase, remove punctuation)
processed_text = "".join(char.lower() for char in text if char.isalnum() or char.isspace())

# Split into words and create bigrams (pairs of consecutive words)
words = processed_text.split()
bigrams = zip(words[:-1], words[1:])

# Create a dictionary to store bigram frequencies
bigram_counts = Counter(bigrams)

# Create a NetworkX graph
G = nx.Graph()

# Add nodes (words) to the graph
for word in set(words):
    G.add_node(word)

# Add edges (bigrams) to the graph with weights based on frequency
for bigram, count in bigram_counts.items():
    G.add_edge(bigram[0], bigram[1], weight=count)

# Optional: Set node sizes based on word frequency (more frequent words have larger size)
node_sizes = [bigram_counts.get((word, ), 0) for word in G.nodes()]

# Create visual output using a layout algorithm (e.g., spring layout)
pos = nx.spring_layout(G)

# Import libraries for visualization (e.g., matplotlib.pyplot)
import matplotlib.pyplot as plt

# Draw the network graph with node sizes and labels
nx.draw_networkx(G, pos, node_size=node_sizes, with_labels=True)

# Customize plot (optional)
plt.title("Bigram Network for Text Data")

# Display the plot
plt.show()

from collections import Counter
import matplotlib.pyplot as plt

# Sample text data
text = "This is a sample text to analyze word frequency distribution. It contains repeated words to showcase the concept."

# Preprocess the text (optional)
# - Convert to lowercase
text = text.lower()
# - Remove punctuation (replace with space)
text = text.replace(",", " ")
text = text.replace(".", " ")

# Split the text into words
words = text.split()

# Count word frequencies
word_counts = Counter(words)

# Extract word list and counts for plotting
word_list = list(word_counts.keys())
counts_list = list(word_counts.values())

# Create the bar chart
plt.figure(figsize=(10, 6))  # Adjust figure size as needed

# Plot the bars
plt.bar(word_list, counts_list)
plt.xticks(rotation=45, ha='right')  # Rotate x-axis labels for better readability
plt.xlabel("Words")
plt.ylabel("Frequency")
plt.title("Word Frequency Distribution")

# Display the chart
plt.tight_layout()
plt.show()

import re
import matplotlib.pyplot as plt
import networkx as nx
from collections import Counter
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.util import bigrams
import nltk
nltk.download('punkt')
nltk.download('stopwords')

text = """
Network graphs are powerful tools for visualizing relationships between entities in a dataset.
In text analysis, they can be used to represent relationships between words, phrases, or other elements.
Use cases include visualizing connections between key concepts, exploring social networks, and analyzing patterns and clusters.
"""

# Preprocessing
text = re.sub(r'\W+', ' ', text.lower())
tokens = word_tokenize(text)
tokens = [word for word in tokens if word not in stopwords.words('english')]

# Generate bigrams
bigram_list = list(bigrams(tokens))
bigram_counts = Counter(bigram_list)

# Create the bigram network
G = nx.Graph()
for (word1, word2), freq in bigram_counts.items():
    G.add_edge(word1, word2, weight=freq)

# Draw the network
plt.figure(figsize=(14, 10))
pos = nx.spring_layout(G, k=0.5)
edges = G.edges(data=True)
weights = [edge[2]['weight'] for edge in edges]

nx.draw(G, pos, with_labels=True, node_size=3000, node_color='skyblue', edge_color='gray', width=weights, font_size=10)
plt.title('Bigram Network Graph')
plt.show()