Added light code files

bert/model.py

@@ -0,0 +1,26 @@
+import torch.nn as nn
+from transformers import CamembertModel
+
+
+class CamembertRegressor(nn.Module):
+    
+    def __init__(self, drop_rate=0.2, freeze_camembert=True):
+        
+        super(CamembertRegressor, self).__init__()
+        D_in, D_out = 768, 1
+        
+        self.camembert = CamembertModel.from_pretrained('camembert-base')
+        self.regressor = nn.Sequential(
+            nn.Dropout(drop_rate),
+            nn.Linear(D_in, D_out))
+        
+        if freeze_camembert:
+            for param in self.camembert.parameters():
+                param.requires_grad = False
+                
+    def forward(self, input_ids, attention_masks):
+        
+        outputs = self.camembert(input_ids, attention_masks)
+        outputs_cls = outputs[1]
+        outputs = self.regressor(outputs_cls)
+        return outputs

bert/performance.py

@@ -0,0 +1,24 @@
+import torch
+from bert.tokenize import extract_inputs_masks, tokenize_encode_corpus
+from torch.utils.data import TensorDataset, DataLoader
+
+
+def predict(samples, tokenizer, scaler, model, device, max_len, batch_size, 
+            return_scaled=False):
+    
+    model.eval()
+    encoded_corpus = tokenize_encode_corpus(tokenizer, samples, max_len)
+    input_ids, attention_mask = extract_inputs_masks(encoded_corpus)
+    input_ids = torch.tensor([input_ids]).to(device)[0]
+    attention_mask = torch.tensor([attention_mask]).to(device)[0]
+    dataset = TensorDataset(input_ids, attention_mask)
+    dataloader = DataLoader(dataset, batch_size)
+    output = []
+    for batch in dataloader:
+        batch_inputs, batch_masks = tuple(b.to(device) for b in batch)
+        with torch.no_grad():
+            output += model(batch_inputs, batch_masks).view(1,-1).tolist()[0]
+    if return_scaled:
+        return output
+    output = scaler.inverse_transform([output])
+    return output.reshape(1,-1).tolist()[0]

bert/preprocess_text.py

@@ -0,0 +1,62 @@
+import pandas as pd
+import re
+
+
+def treat_euro(text):
+    text = re.sub(r'(euro[^s])|(euros)|(€)', ' euros', text)
+    return text
+
+
+def treat_m2(text):
+    text = re.sub(r'(m2)|(m²)', ' m²', text)
+    return text
+
+
+def filter_phone_numbers(text):
+    pattern = r'(?:(?:\+|00)33[\s.-]{0,3}(?:\(0\)[\s.-]{0,3})?|0)[1-9](?:(?:[\s.-]?\d{2}){4}|\d{2}(?:[\s.-]?\d{3}){2})|(\d{2}[ ]\d{2}[ ]\d{3}[ ]\d{3})'
+    text = re.sub(pattern, '', text)
+    return text
+
+
+def filter_ibans(text):
+    pattern = r'fr\d{2}[ ]\d{4}[ ]\d{4}[ ]\d{4}[ ]\d{4}[ ]\d{2}|fr\d{20}|fr[ ]\d{2}[ ]\d{3}[ ]\d{3}[ ]\d{3}[ ]\d{5}'
+    text = re.sub(pattern, '', text)
+    return text
+
+
+def remove_space_between_numbers(text):
+    text = re.sub(r'(\d)\s+(\d)', r'\1\2', text)
+    return text
+
+
+def filter_emails(text):
+    pattern = r'(?:(?!.*?[.]{2})[a-zA-Z0-9](?:[a-zA-Z0-9.+!%-]{1,64}|)|\"[a-zA-Z0-9.+!% -]{1,64}\")@[a-zA-Z0-9][a-zA-Z0-9.-]+(.[a-z]{2,}|.[0-9]{1,})'
+    text = re.sub(pattern, '', text)
+    return text
+
+
+def filter_ref(text):
+    pattern = r'(\(*)(ref|réf)(\.|[ ])\d+(\)*)'
+    text = re.sub(pattern, '', text)
+    return text
+
+
+def filter_websites(text):
+    pattern = r'(http\:\/\/|https\:\/\/)?([a-z0-9][a-z0-9\-]*\.)+[a-z][a-z\-]*'
+    text = re.sub(pattern, '', text)
+    return text
+
+
+def preprocess_text_for_camembert(text):
+    text = text.lower()
+    text = text.replace(u'\xa0', u' ')
+    text = treat_m2(text)
+    text = treat_euro(text)
+    text = filter_phone_numbers(text)
+    text = filter_emails(text)
+    text = filter_ibans(text)
+    text = filter_ref(text)
+    text = filter_websites(text)
+    text = remove_space_between_numbers(text)
+    return text
+    

bert/tokenize.py

@@ -0,0 +1,29 @@
+from transformers import CamembertTokenizer
+
+
+def get_tokenizer(model_name='camembert-base'):
+    tokenizer = CamembertTokenizer.from_pretrained(model_name)
+    return tokenizer
+
+
+def tokenize_encode_corpus(tokenizer, descriptions, max_len):
+
+    encoded_corpus = tokenizer(text=descriptions,
+                            add_special_tokens=True,
+                            padding='max_length',
+                            truncation='longest_first',
+                            max_length=max_len,
+                            return_attention_mask=True)
+    return encoded_corpus
+    
+
+def extract_inputs_masks(encoded_corpus):
+
+    try:
+        input_ids = encoded_corpus['input_ids']
+        attention_mask = encoded_corpus['attention_mask']
+    except:
+        print('Available keys are = ', encoded_corpus.keys())
+        return None
+    return input_ids, attention_mask
+

requirements.txt

@@ -0,0 +1,7 @@
+numpy==1.21.6
+scikit-learn==1.0.2
+torch==1.12.1
+transformers==4.21.3
+sentencepiece==0.1.97
+streamlit==1.12.2
+Babel==2.10.3

text_to_price.py

@@ -0,0 +1,52 @@
+import streamlit as st
+import numpy as np
+import torch
+from babel.numbers import format_currency
+
+from bert.tokenize import get_tokenizer
+from bert.model import CamembertRegressor
+from bert.performance import predict
+
+
+
+
+MODEL_STATE_DICT_PATH = './bert/trained_model/model_epoch_5.pt'
+
+
+
+# ENVRIONMENT SET UP
+if torch.cuda.is_available():       
+    device = torch.device("cuda")
+else:
+    device = torch.device("cpu")
+
+
+# MODEL LOADING
+saved_model_dict = torch.load(MODEL_STATE_DICT_PATH, map_location=device)
+model = CamembertRegressor()
+model.load_state_dict(saved_model_dict['model_state_dict'])
+
+tokenizer = get_tokenizer()
+max_len = saved_model_dict['max_input_len']
+scaler = saved_model_dict['labels_scaler']
+    
+    
+# WEB APP
+st.title("Text 2 Price - Real Estate")
+st.markdown("")
+
+
+example_description = "Superbe maison de 500m2 à Pétaouchnok..."
+description = st.text_area("Décris ton bien immobilier : ", example_description)
+
+
+if (len(description)>0) & (description != example_description):
+    predicted_price = predict([description], tokenizer, scaler, model, device, 
+                              max_len, 32, return_scaled=False)[0]
+    predicted_price_formatted = format_currency(predicted_price, 'EUR', 
+                                                locale='fr_FR')
+    st.markdown('')
+    st.markdown('')
+    st.markdown('On estime que ton bien immobilier serait annoncé à :')
+    st.markdown("<h1 style='text-align: center;'>" \
+                + predicted_price_formatted + "</h1>", unsafe_allow_html=True)