Upload folder using huggingface_hub

README.md

@@ -1,12 +1,6 @@
 ---
-title: Deployment Final Project
-emoji: 🏢
-colorFrom: pink
-colorTo: green
+title: deployment_final_project
+app_file: app.py
 sdk: gradio
 sdk_version: 4.26.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,274 @@
+import grequests
+from bs4 import BeautifulSoup
+import pandas as pd
+import re
+from tqdm import tqdm
+import spacy
+from collections import Counter
+from transformers import pipeline
+from flask import Flask
+from bert_regression import get_ratings_dic
+import os
+from langchain.llms import OpenAI
+import gradio as gr
+
+
+os.environ["OPENAI_API_KEY"] = "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"
+
+app = Flask(__name__)
+
+nlp = spacy.load('../topic_magnet/spacy_model')
+sentiment_pipeline = pipeline("sentiment-analysis", model='my_sentiment_model')
+classifier = pipeline(task="zero-shot-classification", model="my_zero_shot")
+
+product_url = 'https://www.amazon.co.uk/product-reviews/B0B21DW5DL/ref=cm_cr_arp_d_viewopt_sr?ie=UTF8&reviewerType=all_review'
+custom_headers = {
+    # Eliminating non-english reviews
+    "Accept-language": "en;q=1.0",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Cache-Control": "max-age=0",
+    "Connection": "keep-alive",
+    "User-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15",
+}
+
+
+def get_soup(response):
+    if response.status_code != 200:
+        print("Error in getting webpage")
+        return None
+
+    soup = BeautifulSoup(response.text, "html.parser")
+    return soup
+
+
+def get_soup_reviews(soup):
+    review_elements = soup.select("div.review")
+
+    scraped_reviews = []
+
+    for review in review_elements:
+        r_content_element = review.select_one("span.review-text")
+        r_content = r_content_element.text if r_content_element else None
+        preprocessed_review = r_content.replace('\n', '')
+
+        scraped_reviews.append(preprocessed_review)
+
+    return scraped_reviews
+
+
+def scrape_reviews(base_url):
+    all_reviews = []
+    star_ratings = ['one', 'two', 'three', 'four', 'five']
+
+    for star in tqdm(star_ratings):
+        page_number = 1
+
+        while True:
+            url = f"{base_url}&filterByStar={star}_star&&pageNumber={page_number}"
+            response = grequests.get(url, headers=custom_headers).send().response
+            soup = get_soup(response)
+
+            if not soup:
+                continue  # Skip to next star rating if unable to parse page
+
+            reviews = get_soup_reviews(soup)
+            all_reviews.extend(reviews)
+
+            # Note: there's a valid page for any pageNumber,
+            # so we need to stop scraping based on the button of next page
+            # Check for the presence of the "Next page" element
+            next_page_element = soup.find("li", class_="a-disabled a-last")
+            if next_page_element:
+                break  # Exit loop if "Next page" element is found
+
+            page_number += 1
+
+    return all_reviews
+def remove_links(review):
+    pattern = r'\bhttps?://\S+'
+    return re.sub(pattern, '', review)
+
+
+def preprocess_data(df):
+    df.rename(columns={'content': 'Text'}, inplace = True)
+    df.Text = df.Text.astype(str)
+    df['Text'] = df['Text'].str.replace(r'<[^>]*>', '', regex=True)
+    df['Text'] = df['Text'].apply(remove_links)
+    return df
+
+
+def get_noun_ver_adj(reviews):
+    noun_ver_adj = []
+    for i in tqdm(range(reviews.shape[0])):
+        sente = nlp(reviews.iloc[i])
+        for token in sente:
+            noun = adj = adverb = adv_verb = neg = ''
+            if token.dep_ == 'ROOT':
+                for child in token.children:
+                    if child.pos_ == 'NOUN':
+                        noun = child.text
+                    elif child.pos_ == 'ADJ':
+                        adj = child.text
+                        for other_child in child.children:
+                            if other_child.pos_ == 'ADV':
+                                adverb = other_child.text
+                    elif child.pos_ == 'ADV':
+                        adv_verb = child.text
+                    elif child.pos_ == 'PART':
+                        neg = child.text
+                if noun and adj:
+                    if adverb:
+                        noun_ver_adj.append((noun, token.text, adverb, adj))
+                    elif adv_verb and neg:
+                        noun_ver_adj.append((noun, token.text, adv_verb, neg, adj))
+                    elif neg:
+                        noun_ver_adj.append((noun, token.text, neg, adj))
+                    else:
+                        noun_ver_adj.append((noun, token.text, adj))
+    return noun_ver_adj
+
+
+def get_most_common_noun(noun_ver_adj):
+    element_counts_lemma_noun = Counter(nlp(item[0].lower())[0].lemma_ for item in noun_ver_adj)
+    most_common_noun = list(map(lambda x: x[0], element_counts_lemma_noun.most_common(10)))
+    return most_common_noun[:5]
+
+
+def get_insights(topic, noun_ver_adj):
+    list_tuples = [' '.join(x) for x in noun_ver_adj if nlp(x[0].lower())[0].lemma_ == topic]
+    results = sentiment_pipeline(list_tuples)
+    pos = 0
+    neg = 0
+    pos_adj = []
+    neg_adj = []
+    for sentence, result in zip(list_tuples, results):
+        if result['label'] == 'POSITIVE':
+            pos += 1
+            pos_adj.append(sentence.rsplit(None, 1)[-1].lower())
+        else:
+            neg += 1
+            neg_adj.append(sentence.rsplit(None, 1)[-1].lower())
+    most_common_pos_adj = list(map(lambda x: x[0], Counter(pos_adj).most_common(5)))
+    most_common_neg_adj = list(map(lambda x: x[0], Counter(neg_adj).most_common(5)))
+    return most_common_pos_adj, most_common_neg_adj
+
+
+def get_df_all_topics_sent(reviews, sentiment, most_common_noun, threshold=0.6):
+    # Get the dataframe of all topics with the corresponding sentiment (positive or negative)
+    reviews_list = reviews.to_list()
+    hypothesis = f'This product review reflect a {sentiment} sentiment of the {{}}'
+    df_sent = classifier(reviews_list, most_common_noun, hypothesis_template=hypothesis, multi_label=True)
+    df_sent = pd.DataFrame(df_sent)
+    df_sent = df_sent.set_index('sequence').apply(pd.Series.explode).reset_index()
+    df_sent = df_sent[df_sent['scores'] >= threshold]
+    return df_sent
+
+
+def get_both_df(reviews,most_common_noun):
+    # get both df and remove indexes from the positive and negative dataframes where the score is higher in one or the other df
+    df_pos = get_df_all_topics_sent(reviews, 'positive', most_common_noun)
+    print('done')
+    df_neg = get_df_all_topics_sent(reviews, 'negative', most_common_noun)
+    merged_df = pd.merge(df_pos, df_neg, on=['sequence', 'labels'], suffixes=('_pos', '_neg'))
+    to_remove_pos = merged_df[merged_df.scores_pos < merged_df.scores_neg][['sequence', 'labels']]
+    indexes_pos_to_remove = df_pos.reset_index().merge(to_remove_pos, on=['sequence', 'labels'], how='inner').set_index(
+        'index').index
+    to_remove_neg = merged_df[merged_df.scores_pos > merged_df.scores_neg][['sequence', 'labels']]
+    indexes_neg_to_remove = df_neg.reset_index().merge(to_remove_pos, on=['sequence', 'labels'], how='inner').set_index(
+        'index').index
+    df_pos.drop(index=indexes_pos_to_remove, inplace=True)
+    df_neg.drop(index=indexes_neg_to_remove, inplace=True)
+    return df_pos, df_neg
+
+
+def get_df_sent_topic(topic, df_all_topic_sentim):
+    # get the reviews of a specific topic corresponding to the given sentiment
+    df_topic = df_all_topic_sentim[df_all_topic_sentim.labels == topic].copy()
+    df_topic.drop(columns=['labels', 'scores'], inplace=True)
+    return df_topic
+
+
+def get_percentages_topic(topic, df_all_topic_pos, df_all_topic_neg):
+    # get percentages of positive and negative reviews for the given topic
+    df_pos = get_df_sent_topic(topic, df_all_topic_pos)
+    df_neg = get_df_sent_topic(topic, df_all_topic_neg)
+    pos_perc = round(df_pos.shape[0] / (df_pos.shape[0] + df_neg.shape[0]) * 100, 2)
+    neg_perc = round(df_neg.shape[0] / (df_pos.shape[0] + df_neg.shape[0]) * 100, 2)
+    return pos_perc, neg_perc
+
+
+def get_df_adjectives(sentiment, reviews, topic,df_all_topic_sent, noun_ver_adj, threshold=0.6):
+    reviews_list = reviews.to_list()
+    if sentiment == 'positive':
+        adj = get_insights(topic, noun_ver_adj)[0]
+    else:
+        adj = get_insights(topic, noun_ver_adj)[1]
+    hypothesis = f'The {sentiment} sentiment representing the product {topic} is {{}}'
+    df_topic = get_df_sent_topic(topic, df_all_topic_sent)
+    df_adj = classifier(df_topic.sequence.tolist(), adj, hypothesis_template=hypothesis, multi_label=True)
+    df_adj = pd.DataFrame(df_adj)
+    df_adj = df_adj.set_index('sequence').apply(pd.Series.explode).reset_index()
+    df_adj = df_adj[df_adj['scores'] >= threshold]
+    return (df_adj.labels.value_counts(normalize=True).values.round(2) * 100).astype(int), df_adj.labels.value_counts(
+        normalize=True).index.values.astype(str)
+
+def get_topics_adjectives(most_common_noun, noun_ver_adj):
+    dic = {}
+    for i in range(5):
+        dic[most_common_noun[i]] = get_insights(most_common_noun[i], noun_ver_adj)
+    return dic
+
+def generate_feedback(dic, temperature = 0.9):
+  text = f"""Create a summary adressed to a business owner of a product about its reviews.
+We provide the main topics of the reviews with their main attributes. 
+For each topic which are the keys of the dictionary, the first list is positive adjectives and the second is negative.
+Start the text by : 'Dear business owner,'
+You have to create subpart for each topic and explain on the first part of each topic the positive attributes by writing :
+topic :
+positive feedbacks : sentences explaining the positive feedbacks
+negative feedbacks : sentences explaining the negative feedbacks
+Finish the text by signing with this company name : 'The Topic Magnet'.
+Feel free to put many feed lines 
+: {dic}
+   """
+  llm = OpenAI(temperature = temperature, max_tokens = 1000)
+  generated_text = llm(text)
+  #return generated_text.strip().replace('\n',' ')
+  return generated_text.strip()
+
+
+#@app.route('/get_reviews', methods = ['GET'])
+
+def get_reviews(url):
+    df = pd.DataFrame({'Text': scrape_reviews(url)})
+    df = preprocess_data(df)
+    reviews = df.Text
+    noun_ver_adj = get_noun_ver_adj(reviews)
+    most_common_noun = get_most_common_noun(noun_ver_adj)
+    dic1 = get_topics_adjectives(most_common_noun, noun_ver_adj)
+    dic2 = get_ratings_dic(df)
+    generated_text = generate_feedback(dic1)
+    #return jsonify(data1 = dic1, data2 = dic2, data3 = generated_text)
+    return dic2,generated_text
+
+# gr.Interface(fn = get_reviews, inputs = gr.Textbox(), outputs = gr.Textbox(), title = 'The Topic Magnet',
+#             description = 'Enter the url of your Amazon reviews to get real ratings and valuable insights').launch(share = True)
+
+#print(get_reviews(url))
+
+if __name__ == '__main__':
+    interface = gr.Interface(fn=get_reviews, inputs=gr.Textbox(), outputs=[gr.Textbox(label = 'Real ratings'),gr.Textbox(label = 'Actionable insights')], title='The Topic Magnet',
+                             description='Enter the url of your Amazon reviews to get real ratings and valuable insights')
+    interface.launch(share = True)
+    #app.run(host = '0.0.0.0', debug = True, port = 5000)
+
+
+#print(most_common_noun)
+#print(get_insights(most_common_noun[0],noun_ver_adj))
+
+#dfs_topics = get_both_df(reviews,most_common_noun)
+#df_all_topic_pos = dfs_topics[0]
+#df_all_topic_neg = dfs_topics[1]
+#print(get_percentages_topic(most_common_noun[0],df_all_topic_pos,df_all_topic_neg))
+#print(get_df_adjectives('positive',reviews,most_common_noun[0],noun_ver_adj))
+

bert_regression.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import numpy as np
+from datasets import Dataset
+from transformers import AutoTokenizer,AutoModelForSequenceClassification
+import torch
+from itertools import chain
+import re
+def remove_links(review):
+    pattern = r'\bhttps?://\S+'
+    return re.sub(pattern, '', review)
+
+
+# df = pd.read_csv('/Users/danfinel/Downloads/Reviews.csv')
+# df = df.loc[:,['Text']].iloc[:1000]
+# df['Text'] = df['Text'].str.replace(r'<[^>]*>', '', regex=True)
+# df['Text'] = df['Text'].apply(remove_links)
+
+model = AutoModelForSequenceClassification.from_pretrained(
+  '../topic_magnet/bert_regr_other_pretrained', num_labels = 1)
+tokenizer = AutoTokenizer.from_pretrained(
+  '../topic_magnet/bert_regr_other_pretrained')
+
+def preprocess_function_regr(examples):
+    return tokenizer(examples["Text"], truncation=True, max_length=64, padding = 'max_length')
+
+def get_predictions(reviews):
+  #new_test = pd.DataFrame(reviews)
+  new_ds_regr = Dataset.from_pandas(reviews)
+  new_ds_regr_tok = new_ds_regr.map(preprocess_function_regr, remove_columns = ['Text'])
+  input_ids = torch.tensor(new_ds_regr_tok['input_ids'])
+  token_type_ids = torch.tensor(new_ds_regr_tok['token_type_ids'])
+  attention_mask = torch.tensor(new_ds_regr_tok['attention_mask'])
+  with torch.no_grad():
+    outputs = model(input_ids=input_ids, token_type_ids=token_type_ids, attention_mask=attention_mask)
+    predictions = outputs.logits
+  return predictions
+
+def get_ratings_perc(reviews):
+  preds = get_predictions(reviews)
+  predictions_list = list(chain.from_iterable(preds.tolist()))
+  predictions_array = np.clip(predictions_list,1,5)
+  predictions_array = [round(x) for x in predictions_array]
+  sum = np.unique(predictions_array, return_counts = True)[1].sum()
+  ratings_perc = np.unique(predictions_array, return_counts = True)[1]/sum *100
+  return ratings_perc
+
+def get_ratings_dic(reviews):
+  ratings_perc = get_ratings_perc(reviews)
+  dic = {}
+  for i in range(1,6):
+    dic[i] = f'{ratings_perc[i-1].round(2)} %'
+  return dic
+
+#print(get_ratings_dic(df))
+
+
+
+
+# new_test = pd.DataFrame(df.loc[:,'Text'].iloc[:1000])
+# new_ds_regr = Dataset.from_pandas(new_test)
+# new_ds_regr_tok = new_ds_regr.map(preprocess_function_regr, remove_columns = ['Text'])
+#
+# input_ids = torch.tensor(new_ds_regr_tok['input_ids'])
+# token_type_ids = torch.tensor(new_ds_regr_tok['token_type_ids'])
+# attention_mask = torch.tensor(new_ds_regr_tok['attention_mask'])
+# with torch.no_grad():
+#   outputs = model(input_ids=input_ids, token_type_ids=token_type_ids, attention_mask=attention_mask)
+#   predictions = outputs.logits
+#
+# predictions_list = list(chain.from_iterable(predictions.tolist()))
+# predictions_array = np.clip(predictions_list,1,5)
+# predictions_array = [round(x) for x in predictions_array]
+# print(np.unique(predictions_array, return_counts = True))

requirements.txt

@@ -0,0 +1,22 @@
+beautifulsoup4==4.12.3
+datasets==2.18.0
+en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl#sha256=86cc141f63942d4b2c5fcee06630fd6f904788d2f0ab005cce45aadb8fb73889
+fastapi==0.110.1
+Flask==3.0.3
+gevent==24.2.1
+gradio==4.26.0
+grequests==0.7.0
+huggingface-hub==0.22.2
+langchain==0.1.16
+matplotlib==3.8.4
+numpy==1.26.4
+openai==1.17.0
+pandas==2.2.1
+requests==2.31.0
+spacy==3.7.4
+tokenizers==0.15.2
+torch==2.2.2
+tqdm==4.66.2
+transformers==4.39.3
+
+

scraper.py

@@ -0,0 +1,79 @@
+import grequests
+from bs4 import BeautifulSoup
+import pandas as pd
+import time
+import csv
+from tqdm import tqdm
+
+#product_url = "https://www.amazon.co.uk/Smiths-Savoury-Snacks-Favourites-24/product-reviews/B07X2M1D16/ref=cm_cr_dp_d_show_all_btm?ie=UTF8&reviewerType=all_reviews"
+product_url = 'https://www.amazon.co.uk/product-reviews/B0B21DW5DL/ref=cm_cr_arp_d_viewopt_sr?ie=UTF8&reviewerType=all_review'
+custom_headers = {
+    # Eliminating non-english reviews
+    "Accept-language": "en;q=1.0",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Cache-Control": "max-age=0",
+    "Connection": "keep-alive",
+    "User-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15",
+}
+
+
+def get_soup(response):
+    if response.status_code != 200:
+        print("Error in getting webpage")
+        return None
+
+    soup = BeautifulSoup(response.text, "html.parser")
+    return soup
+
+
+def get_reviews(soup):
+    review_elements = soup.select("div.review")
+
+    scraped_reviews = []
+
+    for review in review_elements:
+        r_content_element = review.select_one("span.review-text")
+        r_content = r_content_element.text if r_content_element else None
+        preprocessed_review = r_content.replace('\n', '')
+
+        scraped_reviews.append(preprocessed_review)
+
+    return scraped_reviews
+
+
+def scrape_reviews(base_url):
+    all_reviews = []
+    star_ratings = ['one', 'two', 'three', 'four', 'five']
+
+    for star in tqdm(star_ratings):
+        page_number = 1
+
+        while True:
+            url = f"{base_url}&filterByStar={star}_star&&pageNumber={page_number}"
+            response = grequests.get(url, headers=custom_headers).send().response
+            soup = get_soup(response)
+
+            if not soup:
+                continue  # Skip to next star rating if unable to parse page
+
+            reviews = get_reviews(soup)
+            all_reviews.extend(reviews)
+
+            # Note: there's a valid page for any pageNumber,
+            # so we need to stop scraping based on the button of next page
+            # Check for the presence of the "Next page" element
+            next_page_element = soup.find("li", class_="a-disabled a-last")
+            if next_page_element:
+                break  # Exit loop if "Next page" element is found
+
+            page_number += 1
+
+    return all_reviews
+
+
+print(scrape_reviews(product_url))
+
+
+
+
+

training_bert.py

@@ -0,0 +1,118 @@
+import pandas as pd
+import numpy as np
+import re
+from sklearn.model_selection import GroupShuffleSplit
+def remove_links(review):
+    pattern = r'\bhttps?://\S+'
+    return re.sub(pattern, '', review)
+
+df = pd.read_csv('/Users/danfinel/Downloads/Reviews.csv')
+df['Text'] = df['Text'].str.replace(r'<[^>]*>', '', regex=True)
+df['Text'] = df['Text'].apply(remove_links)
+
+
+splitter_temp = GroupShuffleSplit(test_size=.40, n_splits=1, random_state = 42)
+split_temp = splitter_temp.split(df[:100000], groups=df[:100000]['ProductId'])
+train_inds, temp_inds = next(split_temp)
+
+train = df.iloc[train_inds]
+temp = df.iloc[temp_inds]
+
+splitter_val = GroupShuffleSplit(test_size=.50, n_splits=1, random_state = 42)
+split_val = splitter_val.split(temp, groups=temp['ProductId'])
+val_inds, test_inds = next(split_val)
+
+val = temp.iloc[val_inds]
+test = temp.iloc[test_inds]
+
+X_train = train.drop(columns = 'Score')
+y_train = train.Score
+
+X_val = val.drop(columns = 'Score')
+y_val = val.Score
+
+X_test = test.drop(columns = 'Score')
+y_test = test.Score
+
+from transformers import AutoTokenizer,AutoModelForSequenceClassification
+base_model = 'bert-base-cased'
+learning_rate = 2e-5
+max_length = 64
+batch_size = 32
+epochs = 5
+nbr_samples = 10000
+tokenizer_regr = AutoTokenizer.from_pretrained(base_model)
+model_regr = AutoModelForSequenceClassification.from_pretrained(base_model,num_labels = 1)
+
+X_train_bert = X_train.iloc[:nbr_samples]
+del X_train_bert['ProductId']
+X_train_bert['label'] = y_train.iloc[:nbr_samples].astype(float)
+
+X_val_bert = X_val.iloc[:nbr_samples]
+del X_val_bert['ProductId']
+X_val_bert['label'] = y_val.iloc[:nbr_samples].astype(float)
+
+from datasets import Dataset
+ds_train_regr = Dataset.from_pandas(X_train_bert)
+ds_val_regr = Dataset.from_pandas(X_val_bert)
+
+def preprocess_function_regr(examples):
+    return tokenizer_regr(examples["Text"], truncation=True, max_length=64, padding = 'max_length')
+
+ds_train_regr_tok = ds_train_regr.map(preprocess_function_regr, remove_columns = ['Text'])
+ds_val_regr_tok = ds_val_regr.map(preprocess_function_regr, remove_columns = ['Text'])
+
+from sklearn.metrics import mean_absolute_error
+from sklearn.metrics import mean_squared_error
+from sklearn.metrics import r2_score
+
+def compute_metrics_for_regression(eval_pred):
+    logits, labels = eval_pred
+    labels = labels.reshape(-1, 1)
+
+    mse = mean_squared_error(labels, logits)
+    mae = mean_absolute_error(labels, logits)
+    r2 = r2_score(labels, logits)
+    single_squared_errors = ((logits - labels).flatten()**2).tolist()
+    accuracy = sum([1 for e in single_squared_errors if e < 0.25]) / len(single_squared_errors)
+
+    return {"mse": mse, "mae": mae, "r2": r2, "accuracy": accuracy}
+
+from transformers import TrainingArguments
+
+output_dir = ".."
+
+training_args = TrainingArguments(
+    output_dir = output_dir,
+    learning_rate=learning_rate,
+    per_device_train_batch_size=batch_size,
+    per_device_eval_batch_size=batch_size,
+    num_train_epochs=epochs,
+    evaluation_strategy="epoch",
+    save_strategy="epoch",
+    metric_for_best_model="accuracy",
+    load_best_model_at_end=True,
+    weight_decay=0.01,
+)
+from transformers import Trainer
+import torch
+class RegressionTrainer(Trainer):
+    def compute_loss(self, model, inputs, return_outputs=False):
+        labels = inputs.pop("labels")
+        outputs = model(**inputs)
+        logits = outputs[0][:, 0]
+        loss = torch.nn.functional.mse_loss(logits, labels)
+        return (loss, outputs) if return_outputs else loss
+
+trainer = Trainer(
+    model=model_regr,
+    args=training_args,
+    train_dataset=ds_train_regr_tok,
+    eval_dataset=ds_val_regr_tok,
+    compute_metrics=compute_metrics_for_regression
+)
+
+trainer.train()
+
+tokenizer_regr.save_pretrained('.')
+model_regr.save_pretrained('.', from_pt = True)

transformers_models.py

@@ -0,0 +1,12 @@
+from transformers import pipeline
+import spacy
+
+nlp = spacy.load('en_core_web_sm')
+sentiment_pipeline = pipeline("sentiment-analysis", model='distilbert/distilbert-base-uncased-finetuned-sst-2-english')
+classifier = pipeline(task="zero-shot-classification", model="facebook/bart-large-mnli")
+
+nlp.to_disk('spacy_model')
+
+sentiment_pipeline.save_pretrained('my_sentiment_model')
+
+classifier.save_pretrained('my_zero_shot')