Activity

1. iamnotgoodatprogrammingplshelp commented on Nov 19, 2025

   

   mostly-working-code (iamnotgoodatprogrammingplshelp)

   on Nov 19, 2025

   More actions

   Subject: Small Python syntax fixes to get your bot running

   This is a really solid concept for a lightweight chatbot! However, it currently won't run because of three specific syntax errors regarding Python's "magic methods" and indentation.

   Here is how to fix it:

   Fix the Constructor (The Double Underscores) Python classes require double underscores before and after init to recognize it as the setup function.

   Change: def init(self, pairs=None):

   To: def init(self, pairs=None):
2. PatelNikhil666 commented on Feb 3, 2026

   

   PatelNikhil666

   on Feb 3, 2026

   More actions

   Clean separation of concerns (respond, learn_from_pair, persistence).
   Good fallback handling when confidence is low.
   top_k option adds response variation
   Safe handling of empty datasets.
   Rebuilding the vectorizer on every learn_from_pair is fine for small datasets, but may become slow at scale — consider batching or delayed rebuilds.
   Random selection from top_k could sometimes return weaker matches; you might want to restrict randomization to scores above a higher threshold.
   The similarity threshold (0.25) may need tuning as the dataset grows.
3. iamnotgoodatprogrammingplshelp commented on Feb 3, 2026

   

   mostly-working-code (iamnotgoodatprogrammingplshelp)

   on Feb 3, 2026

   More actions

   so what your problem is is that you have a problem with o(n^2) growth you can use an incremental learner or a Vector Database (like Chroma, Pinecone, or FAISS).

   👍React with 👍1Reacted by PatelNikhil666
4. Hardikrepo commented on Jul 1, 2026

   

   Hardikrepo

   on Jul 1, 2026

   More actions

   Following up on the O(n^2) growth point — here's a minimal-diff fix that avoids refitting the whole TF-IDF vectorizer on every learn_from_pair call, using scipy.sparse.vstack to append incrementally and a periodic rebuild to resync vocabulary:

   from scipy.sparse import vstack
   
   class SimpleChatBot:
       def __init__(self, pairs=None, rebuild_every=20):
           self.pairs = pairs or []
           self.rebuild_every = rebuild_every  # full refit cadence, to resync vocab/IDF
           self._pending_since_rebuild = 0
           self._build_vectorizer()
   
       def _build_vectorizer(self):
           self.user_texts = [p[0] for p in self.pairs]
           if self.user_texts:
               self.vectorizer = TfidfVectorizer(ngram_range=(1, 2), min_df=1)
               self.user_tfidf = self.vectorizer.fit_transform(self.user_texts)
           else:
               self.vectorizer = TfidfVectorizer(ngram_range=(1, 2), min_df=1)
               self.user_tfidf = None
           self._pending_since_rebuild = 0
   
       def learn_from_pair(self, user_text, bot_answer):
           """Add a new example without refitting TF-IDF on every call."""
           user_text, bot_answer = user_text.strip(), bot_answer.strip()
           self.pairs.append((user_text, bot_answer))
           self.user_texts.append(user_text)
   
           if self.user_tfidf is None:
               self._build_vectorizer()  # first example needs a real fit
               return
   
           # Reuse the already-fitted vocabulary/IDF weights instead of refitting.
           new_vec = self.vectorizer.transform([user_text])
           self.user_tfidf = vstack([self.user_tfidf, new_vec])
           self._pending_since_rebuild += 1
   
           # transform() drops n-grams outside the last-fitted vocabulary, so
           # periodically do a full rebuild to pick up new terms/IDF weights.
           if self._pending_since_rebuild >= self.rebuild_every:
               self._build_vectorizer()

   What changed and why:

   • learn_from_pair no longer calls _build_vectorizer() (a full fit_transform over the whole corpus) on every call — that's what made each call cost O(n) and a full session cost O(n²).
   • Instead it calls vectorizer.transform() (reuses existing vocab, no refit) and appends the new row with vstack — O(1) amortized per call.
   • Trade-off: between rebuilds, brand-new n-grams aren't yet in the vocabulary, so they're ignored in scoring for that pair until the next rebuild. rebuild_every (default 20) bounds how stale that gets — tune based on how bursty learning sessions are.
   • For larger scale, a vector DB (FAISS/Chroma, as mentioned above) is still the better long-term answer since it also avoids the linear cosine_similarity scan in respond() — this is just the smallest change that addresses the O(n²) issue directly.
5. Hardikrepo commented on Jul 1, 2026

   

   Hardikrepo

   on Jul 1, 2026

   More actions

   Summary of the fix for the O(n^2) growth issue above:

   The root cause is that learn_from_pair calls _build_vectorizer(), which refits the TF-IDF vectorizer over the entire dataset on every single new example — so each call costs O(n), and a full learning session costs O(n²).

   The fix: instead of refitting on every call, reuse the already-fitted vectorizer's transform() to encode just the new example, and append it to the existing TF-IDF matrix with scipy.sparse.vstack — O(1) amortized per call. A full rebuild only runs periodically (e.g. every 20 additions) to resync the vocabulary/IDF weights with any new terms, bounding the staleness trade-off.

   Full code for the change is in my earlier comment above. For larger-scale use, a vector DB (FAISS/Chroma) is still the better long-term path since it also avoids the linear cosine_similarity scan in respond() — this fix targets just the specific O(n²) concern with a minimal change.