diff --git a/.DS_Store b/.DS_Store
index c808538..7cee99f 100644
Binary files a/.DS_Store and b/.DS_Store differ
diff --git a/README.md b/README.md
index c384e48..6a6ae74 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,746 @@
-# Project_Maui
+# **Project_Maui**
+## **Using News Sentiment to Predict Stoci Price Movements**
Program that allows a user to choose a company from the S&P 500 and run a logistic regression model to predict the price movement of this company's stock on the next trading day based on current sentiment (Vader) of Reuters news articles related to this company.
+## **UX/UI Showcase**
+### _**Choose a Company**_
+
+
+### _**Required Model Accuracy of 20%**_
+
+
+
+### _**Required Model Accuracy of 63%**_
+
+_Please wait till the end for modified recommendation. Thank you for your patience!_
+
+
+
+
+### **Original Goal**
+
+_Should there be access to hourly data on stock prices and news sentiments_
+
+Predict intraday movement in stock price between the current point in time and the end of the trading day to determine if a trade will be profitable by end of day.
+Machine learning model to be implemented that took in average news sentiment between h0 and h-24 (h = hour) as features, and intraday change in price between h0 and 4pm as the target on a rolling single-day basis historically .
+
NOTE: You must have active keys from the following APIs to run this program:
-* IEX Finance: https://iexcloud.io/
-* News API: https://newsapi.org/
+* [IEX Finance](https://iexcloud.io/)
+* [News API](https://newsapi.org/)
+
+_**File to run:**_
+**[project_code > master_function](project_code/master_function.ipynb)**
+
+[_**Link to Project Proposal**_](https://docs.google.com/presentation/d/1oC39MhMv8g4PFlXyPxXt4JyFgs-H_WBuySMOxhCRtT4/edit?usp=sharing)
+
+
+## **Data**
+
+### _**Cleaning and Curation**_
+
+**News Sentiments**
+
+* Pulled 20 Articles per day from news API
+ * Could only pull for past 30 days
+ * Request limitations informed Dataframe Structure
+
+* Sentiments are placed into four categories:
+ * compound, positive, negative and neutral
+
+* Cleaned up articles using Lemmatization and stop word removal
+ * Marginally affected polarity score
+ * Applied Vader Sentiment Analyzer to return Polarity Score
+
+
+ Code (click me)
+
+
+ ```python
+
+ # function to tokenize text
+ def tokenizer(text):
+
+ # cleaning text
+ sw = set(stopwords.words('english'))
+ regex = re.compile("[^a-zA-Z ]")
+ re_clean = regex.sub('', text)
+ words = word_tokenize(re_clean)
+ lem = [lemmatizer.lemmatize(word) for word in words]
+ tokens = [word.lower() for word in lem if word.lower() not in sw]
+
+ # exporting tokenized words as output
+ return tokens
+ ```
+
+
+ Code (click me)
+
+
+ ```python
+
+ # establishing keywords for news pull
+ keyword = f'{company} AND {ticker}'
+ ```
+
+
+Code
+
+
+```python
+
+ # iterating through sentiment score / article DataFrame to...
+ for index, row in dataframe.iterrows():
+
+ # if daily return is null value for a given day - i.e. a non-trading day,
+ if pd.isnull(row['return']):
+
+ # then append polarity scores to their respective lists
+ compound.append(row['compound'])
+ positive.append(row['positive'])
+ negative.append(row['negative'])
+ neutral.append(row['neutral'])
+ dataframe.drop(index=index, inplace=True)
+
+ # if there was a return value - i.e. it was a trading day
+ elif pd.notnull(row['return']):
+
+ # The list of compound polarity scores will be empty if the stock was traded
+ # on the previous day; therefore, move along.
+ if len(compound) == 0:
+ pass
+
+ # If the list is not empty, then at least one day prior was a non-trading
+ # day. Append the current day's scores to the list and calculate the mean
+ # for each score. Then replace the current day's polarity scores with the
+ # average scores of today and previous non-trading days.
+ else:
+ compound.append(row['compound'])
+ compound_mean = np.mean(compound)
+ compound = []
+
+ positive.append(row['positive'])
+ positive_mean = np.mean(positive)
+ positive = []
+
+ negative.append(row['negative'])
+ negative_mean = np.mean(negative)
+ negative = []
+
+ neutral.append(row['neutral'])
+ neutral_mean = np.mean(neutral)
+ neutral = []
+
+ dataframe.at[index, 'compound'] = compound_mean
+ dataframe.at[index, 'positive'] = positive_mean
+ dataframe.at[index, 'negative'] = negative_mean
+ dataframe.at[index, 'neutral'] = neutral_mean
+
+ else:
+ pass
+
+```
+
+
+def get_model_data(company, ticker, lag=0):
+
+
+```python
+ # shifting the return column up to adjust for a lag in stock reaction to sentiments
+ final_df = cleaned_df(combined_df)
+ final_df['return'] = final_df['return'].shift(-lag)
+ final_df.dropna(inplace=True)
+```
+
+
+Evaluation (click me)
+
+
+
+
+
+
+Code (click me)
+
+
+```python
+# ********* MODEL FITTING *************
+ # --------- Loigt -----------
+ # --------Start-------------
+
+M = 'Logit'
+from sklearn import linear_model
+lm = linear_model.LogisticRegression(C = 1e5)
+lm.fit(X_train, y_train)
+lm_pred = lm.predict(X_test)
+
+
+ # --------- Logit ------------
+ # ---------End -------------
+
+```
+
+Evaluation
+
+
+
+
+
+Code
+
+
+```python
+
+# ********* MODEL FITTING *************
+ # -----Balanced Random Forest -------
+ # --------Start-------------
+
+# Resample the training data with the RandomOversampler
+# fit Random Forest Classifier
+from imblearn.ensemble import BalancedRandomForestClassifier
+brf = BalancedRandomForestClassifier(n_estimators=100, random_state=42)
+brf.fit(X_train, y_train)
+brf_pred = brf.predict(X_test)
+
+ # --- Balanced Random Forest --------
+ # --------End-------------
+
+```
+
+Evaluation
+
+
+
+
+
+Code
+
+
+```python
+
+# ********* MODEL FITTING *************
+ # ----- Decision Tree -------
+ # --------Start-------------
+
+from sklearn import tree
+# Needed for decision tree visualization
+import pydotplus
+from IPython.display import Image
+
+# Creating the decision tree classifier instance
+model_tree = tree.DecisionTreeClassifier()
+# Fitting the model
+model_tree = model_tree.fit(X_train, y_train)
+# Making predictions using the testing data
+tree_pred = model_tree.predict(X_test)
+
+ # --- Decision Tree --------
+ # --------End-------------
+
+```
+
+
+Image
+
+
+
+
+
+Code
+
+
+```python
+
+# Creating training and testing data sets
+from sklearn.model_selection import train_test_split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, shuffle=False, random_state=42)
+
+# For neural network sequential, LSTM and ensemble learning
+#Create the StandardScaler instance
+scaler = StandardScaler()
+# Fit the Standard Scaler with the training data
+X_scaler = scaler.fit(X_train)
+
+# Scale the training data - only scale X_train and X_test data
+X_train_scaled = X_scaler.transform(X_train)
+X_test_scaled = X_scaler.transform(X_test)
+
+
+# Creating validation data sets for deep learning on neural network model training
+from sklearn.model_selection import train_test_split
+X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size = 0.3, shuffle=False)
+
+
+```
+
+Code
+
+
+
+```python
+# Score the accuracy
+print("Training vs. Testing - Logit")
+print(f"Training Data Score: {lm.score(X_train, y_train):,.04f}")
+print(f"Testing Data Score: {lm.score(X_test, y_test):,.04f}")
+
+# Evaluating the Logit model in a nicer format
+# Calculating the confusion matrix
+cm_lm = confusion_matrix(y_test, lm_pred)
+cm_lm_df = pd.DataFrame(
+ cm_lm, index=["Actual -1", "Actual 1"], columns=["Predicted -1", "Predicted 1"]
+)
+# Calculating the accuracy score
+acc_lm_score = balanced_accuracy_score(y_test, lm_pred)
+
+# Displaying results
+print("Confusion Matrix - Logit")
+display(cm_lm_df)
+print(f"Balanced Accuracy Score : {acc_lm_score:,.04f}")
+print("Classification Report - Logit")
+print(classification_report(y_test, lm_pred))
+
+```
+
+Graph
+
+
+
+
+Graph
+
+
+
+
+
+Compared to positive and neutral sentiments:
+
+
+
+
+
+
+
+OLS Predicted Returns on News Sentiments in the Past 5 Days
+
+
+
+_Note: Inverted due to complications when multiplying positive and negative signs._
+
+OLS Returns with Rolling Three-day Training Window
+
+
+
+
+
+Code
+
+
+```python
+sigma = (dis['return']/100).std()
+all_predic = all_pred
+all_predic['OLS_predi'] = 0.7 * sigma * (-all_predic['OLS_pred'])
+```
+
+Graph Illustration
+
+
+
+
+Other Model Evaluation Statistics (click me)
+
+
+* **Precision = TP/(TP+FP)**
+ * Out of all the predictions of "1" for daily price increase, how many are actually increased.
+ * It focuses on the data on price increase and uses figuress in the second column of the confusion matrix.
+
+* **Recall = TP/(TP+FN)**
+ * How many actual daily price increase moves are predicted correctly?
+ * It features the second row of the confusion matrix
+ * Recall is also the _**sensitivity**_ of the testing model
+
+* **Specificity = TN/(TN+FP)**
+ * How many of the actuall downward price moves are predicted correctly?
+ * It spotlight the first row of our confusion matrix and examine only the downward price moves in our data.
+
+* **F1 = 2 x (Precision x Recall)/(Precision + Recall)**
+ * F1 score is the harmonic mean of precision and recall.
+ * As precission and recall usually go in opposite directions, f1 score is a good balance between the two.
+ * F1 leverages the second row and column for actual and predicted upward price moves.
+
+
+The original code appears as follows:
+
+
+```python
+def signal_column(df):
+ df['test'] = None
+ for index, row in df.iterrows():
+ if pd.isnull(row['test']):
+ if df.loc[index]['return'] >= 2:
+ df.at[index, 'test'] = 1
+ elif df.loc[index]['return'] <= -2:
+ df.at[index, 'test'] = -1
+ else:
+ df.at[index, 'test'] = 0
+ return df
+
+```
+
+
+a. on get_model_data(company, ticker, lag=0) function
+
+
+
+
+
+b. on on_button_clicked(b) function
+
+
+
+
+
+c. on the model(df) function
+
+
+
+```python
+
+# defining model to run Logit logistic regression model on the feature/target DataFrame
+# and export predicted price movement and model accuracy
+def model(df):
+ # preparing the dataframe
+ df['return_sign'] = None
+ for index, row in df.iterrows():
+ if pd.isnull(row['return_sign']):
+ if df.loc[index]['return'] >= 2:
+ df.at[index, 'return_sign'] = 1
+ elif df.loc[index]['return'] <= -2:
+ df.at[index, 'return_sign'] = -1
+ else:
+ df.at[index, 'return_sign'] = 0
+ df = df.drop(columns=['text'])
+ # creating the features (X) and target (y) sets
+ X = df.iloc[:, 0:4]
+ y = df["return_sign"]
+ # creating training and testing data sets
+ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, shuffle=False, random_state=42)
+ # fitting model
+ M = 'Logit'
+ lm = linear_model.LogisticRegression(solver = 'lbfgs')
+ lm.fit(X_train, y_train)
+ lm_pred = lm.predict(X_test)
+ # calculating confusion matrix
+ cm_lm = confusion_matrix(y_test, lm_pred)
+ cm_lm_df = pd.DataFrame(
+ cm_lm, index=["Actual -1", "Actual 1"], columns=["Predicted -1", "Predicted 1"]
+ )
+ # calculating the accuracy score
+ acc_lm_score = balanced_accuracy_score(y_test, lm_pred)
+ # exporting model accuracy and predicted price movement float variables as output
+ return acc_lm_score, lm_pred[-1]
+
+```
+