turns-00042.parquet:7291
cb3cf95ca488628936928bcfdegenerate_repetitionAbsentFinal dense release
USER
#from semantic_split import SimilarSentenceSplitter, SentenceTransformersSimilarity, SpacySentenceSplitter
import spacy
from typing import List
from sentence_transformers import SentenceTransformer, util
import spacy
class SentenceTransformersSimilarity:
def __init__(self, model="all-MiniLM-L6-v2", similarity_threshold=0.2):
self.model = SentenceTransformer(model)
self.similarity_threshold = similarity_threshold
def similarities(self, sentences: List[str]):
# Encode all sentences
embeddings = self.model.encode(sentences)
# Calculate cosine similarities for neighboring sentences
similarities = []
for i in range(1, len(embeddings)):
sim = util.pytorch_cos_sim(embeddings[i - 1], embeddings[i]).item()
similarities.append(sim)
return similarities
class SpacySentenceSplitter():
def __init__(self):
self.nlp = spacy.load("en_core_web_sm")
def split(self, text: str) -> List[str]:
doc = self.nlp(text)
return [str(sent).strip() for sent in doc.sents]
def split_text(self, text: str, group_max_sentences=5) -> List[str]:
sentences = self.sentence_splitter.split(text)
if len(sentences) == 0:
return []
similarities = self.model.similarities(sentences)
groups = [[sentences[0]]]
for i in range(1, len(sentences)):
# Überprüfen Sie, ob die maximale Gruppengröße erreicht wurde
if len(groups[-1]) >= group_max_sentences:
groups.append([sentences[i]])
# Überprüfe die Ähnlichkeit zum nächsten Satz
elif similarities[i - 1] >= self.model.similarity_threshold:
groups[-1].append(sentences[i])
else:
groups.append([sentences[i]])
# Fügen Sie debuggin Informationen hinzu, um Satzschritte zu sehen
for idx, group in enumerate(groups):
print(f"Group {idx + 1}: {[sentence for sentence in group]}")
return [" ".join(g) for g in groups]
class SimilarSentenceSplitter():
def __init__(self, similarity_model, sentence_splitter):
self.model = similarity_model
self.sentence_splitter = sentence_splitter
def split_text(self, text: str, group_max_sentences=5) -> List[str]:
"""
group_max_sentences: The maximum number of sentences in a group.
"""
sentences = self.sentence_splitter.split(text)
if len(sentences) == 0:
return []
similarities = self.model.similarities(sentences)
# The first sentence is always in the first group.
groups = [[sentences[0]]]
# Using the group min/max sentences contraints,
# group together the rest of the sentences.
for i in range(1, len(sentences)):
if len(groups[-1]) >= group_max_sentences:
groups.append([sentences[i]])
elif similarities[i - 1] >= self.model.similarity_threshold:
groups[-1].append(sentences[i])
else:
groups.append([sentences[i]])
return [" ".join(g) for g in groups]
text = """
1 Bodenchemie
Schwefel ist notwendig für den Humusaufbau. Bei den Leguminosen zeigte sich ein riesen Unterschied: 25kg/ha Schwefel 3450 kg/ha; ohne nur 1940 kg/ha!
Ohne eine Krümelstruktur hat man auch kein Porenvolumen und daher auch keinen Sauerstoff im Boden.
Die Pflanzen sind der Schlüssel für den Bodenaufbau. Daher muss man Wissen welche Aufgabe die Pflanzen haben.
zBsp.: Ampfer oder Ackerfuchsschwanz
2 Nährstoffgleichgewichte
Die Nährstoffe bilden die Bodenstruktur!
Die Ionengröße bestimmt die Wasserbindestruktur. Na+>H+>K+>Mg2+>Ca2+
Wenn im Boden die Nährstoffe ungleichmäßig verteilt sind, dann hat die Bodenbiologie ein Problem.
Humus ist S Lieferant. Solange der Humus nicht aufgebaut ist, muss Schwefel gedüngt werden.
Bor wird zuerst benötigt, damit andere Nährstoffe und Spurenelemente aufgenommen werden können.
Die Nährstoffe sollten im Herbst oder in den wachsenden Bestand gegeben werden, damit alle mikrobiologisch in den Boden eingebaut werden können."""
model = SentenceTransformersSimilarity()
sentence_splitter = SpacySentenceSplitter()
splitter = SimilarSentenceSplitter(model, sentence_splitter)
res = splitter.split_text(text)
for i, split in enumerate(res):
print(f"**Split {i+1}**")
print(split)
print()
zur prüfung hätte ich gerne die ähnlichkeiten zwischen den chunks gesehen, bitte print empfehlenASSISTANT
Um die Ähnlichkeiten zwischen den Chunks anzuzeigen, können Sie zusätzliche Print-Anweisungen hinzufügen, um die berechneten Similarity-Werte auszugeben. Der sinnvollste Ort, um dies zu tun, ist innerhalb der `split_text`-Methode Ihrer `SimilarSentenceSplitter`-Klasse, da dort die Satzähnlichkeiten berechnet und verwendet werden.
Hier ist, wie Sie dies tun können:
### Anpassungen in Ihrem Code
Fügen Sie einen Print-Befehl hinzu, um die Ähnlichkeiten anzuzeigen, während die Sätze zu Chunks gruppiert werden:
```python
class SimilarSentenceSplitter():
def __init__(self, similarity_model, sentence_splitter):
self.model = similarity_model
self.sentence_splitter = sentence_splitter
def split_text(self, text: str, group_max_sentences=5) -> List[str]:
sentences = self.sentence_splitter.split(text)
if len(sentences) == 0:
return []
similarities = self.model.similarities(sentences)
# The first sentence is always in the first group.
groups = [[sentences[0]]]
# Print similarities with corresponding sentence pairs
print("\nSimilarities between consecutive sentences:")
for i, sim in enumerate(similarities):
print(f"Similarity between sentence {i} and {i+1}: {sim:.4f}")
# Using the group min/max sentence constraints, group together the rest of the sentences.
for i in range(1, len(sentences)):
if len(groups[-1]) >= group_max_sentences:
groups.append([sentences[i]])
elif similarities[i - 1] >= self.model.similarity_threshold:
groups[-1].append(sentences[i])
else:
groups.append([sentences[i]])
return [" ".join(g) for g in groups]
```
### Erklärung
1. **Calculate Similarities**: Sobald die Similarity-Werte für benachbarte Sätze berechnet sind, drucken wir diese mit `print(f"Similarity between...")`.
2. **Debugging Information**: Diese Ausgabe wird Ihnen dabei helfen zu verstehen, wie Sätze auf Basis ihrer Ähnlichkeit gruppiert werden. Hohe Ähnlichkeiten deuten darauf hin, dass Sätze wahrscheinlich im selben Chunk landen, während niedrige Ähnlichkeiten wahrscheinlich zu einer Trennung führen.
3. **Am Bildschirm sichtbar machen**: Indem die Ähnlichkeiten in der Konsole ausgegeben werden, erhalten Sie einen direkten Einblick in die Entscheidungsfindung des Chunkings.
Führen Sie den Code mit diesen Anpassungen aus, um zusätzliche Einblicke in die Ähnlichkeitsberechnungen zwischen den Sätzen zu erhalten und besser zu verstehen, wie die Chunks gebildet werden.