add transformers emmbeddings and UMAP

app.py

@@ -1,9 +1,9 @@
 from umap_reducer import UMAPReducer
+from embeddings_encoder import EmbeddingsEncoder
 from flask import Flask, request, render_template, jsonify, make_response
 from flask_cors import CORS
 import os
 from dotenv import load_dotenv
-from transformers import pipeline
 import feedparser
 import json
 from dateutil import parser
@@ -13,12 +13,10 @@ import gzip
 
 load_dotenv()
 
-# Load Setiment Classifier
-# sentiment_analysis = pipeline(
-#     "sentiment-analysis", model="siebert/sentiment-roberta-large-english")
+
 app = Flask(__name__, static_url_path='/static')
 reducer = UMAPReducer()
-
+encoder = EmbeddingsEncoder()
 CORS(app)
 
 
@@ -27,87 +25,34 @@ def index():
     return render_template('index.html')
 
 
-@app.route('/run-umap')  # //methods=['POST'])
+@app.route('/run-umap', methods=['POST'])
 def run_umap():
-    data = np.random.rand(512, 4)
-
-    # UMAP embeddings
-    embeddings = reducer.embed(data)
-
-    content = gzip.compress(json.dumps(embeddings.tolist()).encode('utf8'), 5)
-    response = make_response(content)
-    response.headers['Content-length'] = len(content)
-    response.headers['Content-Encoding'] = 'gzip'
-    return response
-
-
-# @app.route('/news')
-# def get_news():
-#     feed_url = request.args.get('feed_url')
-#     # check if string is a valid
-
-#     # file name for cache
-#     file_name = "".join(re.split(r"https://|\.|/", feed_url))
-
-#     feed_entries = get_feed(feed_url)
-#     # filter only titles for sentiment analysis
-#     try:
-#         with open(f'{file_name}_cache.json') as file:
-#             cache = json.load(file)
-#     except:
-#         cache = {}
-
-#     # if new homepage is newer than cache, update cache and return
-#     print("new date", feed_entries['last_update'])
-#     print("old date", cache['last_update']
-#           if 'last_update' in cache else "None")
-#     if not cache or parser.parse(feed_entries['last_update']) > parser.parse(cache['last_update']):
-#         print("Updating cache with new preditions")
-#         titles = [entry['title'] for entry in feed_entries['entries']]
-#         # run sentiment analysis on titles
-#         predictions = [sentiment_analysis(sentence) for sentence in titles]
-#         # parse Negative and Positive, normalize to -1 to 1
-#         predictions = [-prediction[0]['score'] if prediction[0]['label'] ==
-#                        'NEGATIVE' else prediction[0]['score'] for prediction in predictions]
-#         # merge rss data with predictions
-#         entries_predicitons = [{**entry, 'sentiment': prediction}
-#                                for entry, prediction in zip(feed_entries['entries'], predictions)]
-#         output = {'entries': entries_predicitons,
-#                   'last_update': feed_entries['last_update']}
-#         # update last precitions cache
-#         with open(f'{file_name}_cache.json', 'w') as file:
-#             json.dump(output, file)
-#         # send back json
-#         return jsonify(output)
-#     else:
-#         print("Returning cached predictions")
-#         return jsonify(cache)
-
-
-# @ app.route('/predict', methods=['POST'])
-# def predict():
-#     # get data from POST
-#     if request.method == 'POST':
-#         # get current news
-#         # get post body data
-#         data = request.get_json()
-#         if data.get('sentences') is None:
-#             return jsonify({'error': 'No text provided'})
-#         # get post expeceted to be under {'sentences': ['text': '...']}
-#         sentences = data.get('sentences')
-#         # prencit sentiments
-#         predictions = [sentiment_analysis(sentence) for sentence in sentences]
-#         # parse Negative and Positive, normalize to -1 to 1
-#         predictions = [-prediction[0]['score'] if prediction[0]['label'] ==
-#                        'NEGATIVE' else prediction[0]['score'] for prediction in predictions]
-#         output = [dict(sentence=sentence, sentiment=prediction)
-#                   for sentence, prediction in zip(sentences, predictions)]
-#         # send back json
-#         return jsonify(output)
+    input_data = request.get_json()
+    sentences = input_data['data']['sentences']
+    umap_options = input_data['data']['umap_options']
+    cluster_options = input_data['data']['cluster_options']
+
+    print("input options:", umap_options, cluster_options)
+    try:
+        embeddings = encoder.encode(sentences)
+        # UMAP embeddings
+        reducer.setParams(umap_options, cluster_options)
+        umap_embeddings = reducer.embed(embeddings)
+        # HDBScan cluster analysis
+        clusters = reducer.clusterAnalysis(umap_embeddings)
+        content = gzip.compress(json.dumps(
+            {
+                "embeddings": umap_embeddings.tolist(),
+                "clusters": clusters.labels_.tolist()
+            }
+        ).encode('utf8'), 5)
+        response = make_response(content)
+        response.headers['Content-length'] = len(content)
+        response.headers['Content-Encoding'] = 'gzip'
+        return response
+    except Exception as e:
+        return jsonify({"error": str(e)}), 201
 
 
-# def get_feed(feed_url):
-#     feed = feedparser.parse(feed_url)
-#     return {'entries': feed['entries'], 'last_update': feed["feed"]['updated']}
 if __name__ == '__main__':
     app.run(host='0.0.0.0',  port=int(os.environ.get('PORT', 7860)))

embeddings_encoder.py

@@ -0,0 +1,45 @@
+# from https://huggingface.co/sentence-transformers/multi-qa-MiniLM-L6-cos-v1
+from transformers import AutoTokenizer, AutoModel
+import torch
+import torch.nn.functional as F
+
+
+class EmbeddingsEncoder:
+    def __init__(self):
+        # Load model from HuggingFace Hub
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            'sentence-transformers/all-MiniLM-L6-v2')
+        self.model = AutoModel.from_pretrained(
+            'sentence-transformers/all-MiniLM-L6-v2')
+
+    # Mean Pooling - Take average of all tokens
+
+    def mean_pooling(self, model_output, attention_mask):
+        # First element of model_output contains all token embeddings
+        token_embeddings = model_output.last_hidden_state
+        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+    # Encode text
+
+    def encode(self,  texts):
+        # Tokenize sentences
+        print("Tokenizing...")
+        encoded_input = self.tokenizer(
+            texts, padding=True, truncation=True, return_tensors='pt')
+
+        # Compute token embeddings
+        print("Computing embeddings...")
+        with torch.no_grad():
+            model_output = self.model(**encoded_input, return_dict=True)
+
+        # Perform pooling
+        print("Performing pooling...")
+        embeddings = self.mean_pooling(
+            model_output, encoded_input['attention_mask'])
+
+        # Normalize embeddings
+        print("Normalizing embeddings...")
+        embeddings = F.normalize(embeddings, p=2, dim=1)
+
+        return embeddings

umap_reducer.py

@@ -2,36 +2,26 @@ import umap
 import hdbscan
 import copy
 
+
 class UMAPReducer:
-    def __init__(self, options={}):
+    def __init__(self, umap_options={}, cluster_options={}):
 
         # set options with defaults
-        options = {'n_components': 3, 'spread': 1, 'min_dist': 0.1, 'n_neighbors': 15,
-                   'metric': 'hellinger', 'min_cluster_size': 60, 'min_samples': 15, **options}
-
-        print(options)
-        self.reducer = umap.UMAP(
-            n_neighbors=options['n_neighbors'],
-            min_dist=options['min_dist'],
-            n_components=options['n_components'],
-            metric=options['metric'],
-            verbose=True)
-        # cluster init
-        self.clusterer = hdbscan.HDBSCAN(
-            min_cluster_size=options['min_cluster_size'],
-            min_samples=options['min_samples'],
-            allow_single_cluster=True
-        )
-        self.cluster_params = copy.deepcopy(options)
+        self.umap_options = {'n_components': 2, 'spread': 1, 'min_dist': 0.1, 'n_neighbors': 15,
+                             'metric': 'cosine', "verbose": True, **umap_options}
+        self.cluster_options = {'allow_single_cluster': True, 'min_cluster_size': 500, 'min_samples': 10, **cluster_options}
 
-    def setParams(self, options):
+    def setParams(self, umap_options={}, cluster_options={}):
         # update params
-        self.cluster_params = {**self.cluster_params, **options}
+        self.umap_options = {**self.umap_options, **umap_options}
+        self.cluster_options = {**self.cluster_options, **cluster_options}
 
     def clusterAnalysis(self, data):
-        clusters = self.clusterer.fit(data)
+        print("Cluster params:", self.cluster_options)
+        clusters = hdbscan.HDBSCAN().fit(data) # **self.cluster_options
         return clusters
 
     def embed(self, data):
-        result = self.reducer.fit_transform(data)
+        print("UMAP params:", self.umap_options)
+        result = umap.UMAP(**self.umap_options).fit_transform(data)
         return result