File size: 9,397 Bytes
46a1213 01cc880 ff68008 01cc880 ff68008 01cc880 ff68008 01cc880 ff68008 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 |
#v3/modules/studentact/current_situation_analysis.py
import streamlit as st
import matplotlib.pyplot as plt
import networkx as nx
import seaborn as sns
import logging
logger = logging.getLogger(__name__)
def display_current_situation_visual(doc, metrics):
"""
Crea y muestra las visualizaciones del an谩lisis de situaci贸n actual.
Aprovecha los componentes visuales existentes del sistema.
"""
try:
# Contenedor principal para visualizaciones
with st.container():
# 1. Red de Vocabulario
st.subheader("Riqueza de Vocabulario")
vocabulary_graph = create_vocabulary_network(doc)
st.pyplot(vocabulary_graph)
# 2. Complejidad Sint谩ctica
st.subheader("Estructura de Oraciones")
syntax_graph = create_syntax_complexity_graph(doc)
st.pyplot(syntax_graph)
# 3. Cohesi贸n Textual
st.subheader("Cohesi贸n del Texto")
cohesion_map = create_cohesion_heatmap(doc)
st.pyplot(cohesion_map)
except Exception as e:
logger.error(f"Error mostrando visualizaciones: {str(e)}")
st.error("Error al generar visualizaciones")
def analyze_text_dimensions(doc):
"""
Analiza las diferentes dimensiones del texto.
Args:
doc: Documento procesado por spaCy
Returns:
dict: M茅tricas del an谩lisis
"""
try:
# Analizar claridad (basado en longitud de oraciones)
clarity_score = analyze_clarity(doc)
# Analizar vocabulario (diversidad l茅xica)
vocabulary_score = analyze_vocabulary_diversity(doc)
# Analizar cohesi贸n (conexiones entre oraciones)
cohesion_score = analyze_cohesion(doc)
# Analizar estructura (complejidad sint谩ctica)
structure_score = analyze_structure(doc)
# Generar gr谩ficos
sentence_graphs = generate_sentence_graphs(doc)
word_connections = generate_word_connections(doc)
connection_paths = generate_connection_paths(doc)
return {
'clarity': clarity_score,
'vocabulary': vocabulary_score,
'cohesion': cohesion_score,
'structure': structure_score,
'sentence_graphs': sentence_graphs,
'word_connections': word_connections,
'connection_paths': connection_paths
}
except Exception as e:
logger.error(f"Error en analyze_text_dimensions: {str(e)}")
raise
def analyze_clarity(doc):
"""Analiza la claridad basada en longitud de oraciones"""
sentences = list(doc.sents)
avg_length = sum(len(sent) for sent in sentences) / len(sentences)
return normalize_score(avg_length, optimal_length=20)
def analyze_vocabulary_diversity(doc):
"""Analiza la diversidad del vocabulario"""
unique_lemmas = {token.lemma_ for token in doc if token.is_alpha}
total_words = len([token for token in doc if token.is_alpha])
return len(unique_lemmas) / total_words if total_words > 0 else 0
def analyze_cohesion(doc):
"""Analiza la cohesi贸n textual"""
sentences = list(doc.sents)
connections = 0
for i in range(len(sentences)-1):
sent1_words = {token.lemma_ for token in sentences[i]}
sent2_words = {token.lemma_ for token in sentences[i+1]}
connections += len(sent1_words.intersection(sent2_words))
return normalize_score(connections, optimal_connections=5)
def analyze_structure(doc):
"""Analiza la complejidad estructural"""
root_distances = []
for token in doc:
if token.dep_ == 'ROOT':
depths = get_dependency_depths(token)
root_distances.extend(depths)
avg_depth = sum(root_distances) / len(root_distances) if root_distances else 0
return normalize_score(avg_depth, optimal_depth=3)
def get_dependency_depths(token, depth=0):
"""Obtiene las profundidades de dependencia"""
depths = [depth]
for child in token.children:
depths.extend(get_dependency_depths(child, depth + 1))
return depths
def normalize_score(value, optimal_value=1.0, range_factor=2.0):
"""Normaliza un valor a un score entre 0 y 1"""
return 1 / (1 + abs(value - optimal_value) / range_factor)
# Implementaci贸n de las funciones de visualizaci贸n
def generate_sentence_graphs(doc):
"""Genera visualizaciones de estructura de oraciones"""
fig, ax = plt.subplots(figsize=(10, 6))
# Implementar visualizaci贸n
plt.close()
return fig
def generate_word_connections(doc):
"""Genera red de conexiones de palabras"""
fig, ax = plt.subplots(figsize=(10, 6))
# Implementar visualizaci贸n
plt.close()
return fig
def generate_connection_paths(doc):
"""Genera patrones de conexi贸n"""
fig, ax = plt.subplots(figsize=(10, 6))
# Implementar visualizaci贸n
plt.close()
return fig
def create_vocabulary_network(doc):
"""
Genera el grafo de red de vocabulario.
"""
G = nx.Graph()
# Crear nodos para palabras significativas
words = [token.text.lower() for token in doc if token.is_alpha and not token.is_stop]
word_freq = Counter(words)
# A帽adir nodos con tama帽o basado en frecuencia
for word, freq in word_freq.items():
G.add_node(word, size=freq)
# Crear conexiones basadas en co-ocurrencia
window_size = 5
for i in range(len(words) - window_size):
window = words[i:i+window_size]
for w1, w2 in combinations(set(window), 2):
if G.has_edge(w1, w2):
G[w1][w2]['weight'] += 1
else:
G.add_edge(w1, w2, weight=1)
# Crear visualizaci贸n
fig, ax = plt.subplots(figsize=(12, 8))
pos = nx.spring_layout(G)
# Dibujar nodos
nx.draw_networkx_nodes(G, pos,
node_size=[G.nodes[node]['size']*100 for node in G.nodes],
node_color='lightblue',
alpha=0.7)
# Dibujar conexiones
nx.draw_networkx_edges(G, pos,
width=[G[u][v]['weight']*0.5 for u,v in G.edges],
alpha=0.5)
# A帽adir etiquetas
nx.draw_networkx_labels(G, pos)
plt.title("Red de Vocabulario")
plt.axis('off')
return fig
def create_syntax_complexity_graph(doc):
"""
Genera el diagrama de arco de complejidad sint谩ctica.
Muestra la estructura de dependencias con colores basados en la complejidad.
"""
try:
# Preparar datos para la visualizaci贸n
sentences = list(doc.sents)
if not sentences:
return None
# Crear figura para el gr谩fico
fig, ax = plt.subplots(figsize=(12, len(sentences) * 2))
# Colores para diferentes niveles de profundidad
depth_colors = plt.cm.viridis(np.linspace(0, 1, 6))
y_offset = 0
max_x = 0
for sent in sentences:
words = [token.text for token in sent]
x_positions = range(len(words))
max_x = max(max_x, len(words))
# Dibujar palabras
plt.plot(x_positions, [y_offset] * len(words), 'k-', alpha=0.2)
plt.scatter(x_positions, [y_offset] * len(words), alpha=0)
# A帽adir texto
for i, word in enumerate(words):
plt.annotate(word, (i, y_offset), xytext=(0, -10),
textcoords='offset points', ha='center')
# Dibujar arcos de dependencia
for token in sent:
if token.dep_ != "ROOT":
# Calcular profundidad de dependencia
depth = 0
current = token
while current.head != current:
depth += 1
current = current.head
# Determinar posiciones para el arco
start = token.i - sent[0].i
end = token.head.i - sent[0].i
# Altura del arco basada en la distancia entre palabras
height = 0.5 * abs(end - start)
# Color basado en la profundidad
color = depth_colors[min(depth, len(depth_colors)-1)]
# Crear arco
arc = patches.Arc((min(start, end) + abs(end - start)/2, y_offset),
width=abs(end - start),
height=height,
angle=0,
theta1=0,
theta2=180,
color=color,
alpha=0.6)
ax.add_patch(arc)
y_offset -= 2
# Configurar el gr谩fico
plt.xlim(-1, max_x)
plt.ylim(y_offset - 1, 1)
plt.axis('off')
plt.title("Complejidad Sint谩ctica")
return fig
except Exception as e:
logger.error(f"Error en create_syntax_complexity_graph: {str(e)}")
return None
|