Added new GPTs for Black Friday

gpts/mastercodeimprovementagent.md

@@ -0,0 +1,721 @@
+
+[![~The Master of Code Improvement~](https://flow-prompt-covers.s3.us-west-1.amazonaws.com/icon/Flat/i13.png)]()
+# ~The Master of Code Improvement~ 
+This is a great prompt for:
+
+
+
+1.) Iteratively improving any code chunks up to about 300 lines or so at a time, how?
+
+
+
+2.) Input the block of code you'd like analyzed, rated and improved.
+
+
+
+3.) The model will then rate the code and provide suggestions for improvement.
+
+
+
+4.) After the model rates & suggests improvements, input "return [user specified improvements and/or AI suggested improvements here]"
+
+
+
+5.) Then, an improved version of code with user specifications, including all methods, classes, functions, and logic will be output.
+
+
+
+6.) BEST PART!? You can iteratively improve code over and over by a rinse/repeat with the copy/paste of the improved code the model outputs, restart convo, and continually improve functionality and capability of your code!💡
+
+# Prompt
+
+```
+**You will be given a block of code.**You will **return a rating out of 10** - and *give a list (numerically)* of **how the code can be improved.** If the *user provides and instruction,* such as **'return [something]' you will run that as if you were to **output the *entire code* in a single code block. Minimize any other prose. It is of **paramount importance** to *include* **ALL LOGIC**
+
+**WAIT** for **USER_INPUT** *before* outputting any code examples. Output the text within the 'Welcome Message' to properly introduce the chat.
+
+Code always returns in unique code block like '''' code ''''
+
+```
+
+## Conversation
+
+**ASSISTANT**: Welcome to the code review chat! Please provide the code that you would like me to review.
+**USER**: import numpy as np
+
+import pandas as pd
+
+from sklearn.preprocessing import MinMaxScaler
+
+from keras.models import Sequential
+
+from keras.layers import Dense, LSTM, Dropout
+
+from transformers import BertTokenizer, TFBertForSequenceClassification
+
+from sklearn.ensemble import IsolationForest
+
+from rl.agents.dqn import DQNAgent
+
+from rl.policy import BoltzmannQPolicy
+
+from rl.memory import SequentialMemory
+
+from openai import GPT3Completion
+
+from bs4 import BeautifulSoup
+
+import requests
+
+import re
+
+
+
+
+
+# Download historical market data
+
+data = yf.download('GOOG', start='2020-01-01', end='2022-12-31')
+
+
+
+# Prepare data
+
+dataset = data['Close'].values
+
+training_data_len = int(np.ceil( len(dataset) * .8 ))
+
+
+
+scaler = MinMaxScaler(feature_range=(0,1))
+
+scaled_data = scaler.fit_transform(dataset.reshape(-1,1))
+
+
+
+train_data = scaled_data[0:int(training_data_len), :]
+
+
+
+x_train=[]
+
+y_train = []
+
+
+
+for i in range(60,len(train_data)):
+
+    x_train.append(train_data[i-60:i,0])
+
+    y_train.append(train_data[i,0])
+
+
+
+x_train, y_train = np.array(x_train), np.array(y_train)
+
+
+
+x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1))
+
+
+
+class ComprehensiveTradingSystem:
+
+    def __init__(self):
+
+        self.tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+
+        self.sentiment_model = TFBertForSequenceClassification.from_pretrained('bert-base-uncased')
+
+        self.price_model = self.build_lstm_model()
+
+        self.price_model.compile(optimizer='adam', loss='mean_squared_error')
+
+
+
+    def build_lstm_model(self):
+
+        model = Sequential()
+
+        model.add(LSTM(units=50, return_sequences=True,input_shape=(60,1)))
+
+        model.add(Dropout(0.2))
+
+        model.add(LSTM(units=50, return_sequences=False))
+
+        model.add(Dropout(0.2))
+
+        model.add(Dense(units=25))
+
+        model.add(Dense(units=1))
+
+        return model
+
+
+
+    def train_price_model(self, data):
+
+        scaler = MinMaxScaler(feature_range=(0,1))
+
+        scaled_data = scaler.fit_transform(data)
+
+
+
+        x_train=[]
+
+        y_train = []
+
+
+
+        for i in range(60,len(scaled_data)):
+
+            x_train.append(scaled_data[i-60:i,0])
+
+            y_train.append(scaled_data[i,0])
+
+
+
+        x_train, y_train = np.array(x_train), np.array(y_train)
+
+
+
+        x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1))
+
+
+
+        self.price_model.fit(x_train, y_train, batch_size=1, epochs=1)
+
+
+
+    def predict_prices(self, data):
+
+        test_data = data[-60:, :]
+
+
+
+        x_test = []
+
+        for i in range(60,len(test_data)):
+
+            x_test.append(test_data[i-60:i,0])
+
+
+
+        x_test = np.array(x_test)
+
+
+
+        x_test = np.reshape(x_test, (x_test.shape[0],x_test.shape[1],1))
+
+
+
+        predictions = self.price_model.predict(x_test) 
+
+        
+
+        return predictions
+
+
+
+    def sentiment_score(self, review):
+
+        inputs = self.tokenizer.encode_plus(
+
+            review,
+
+            None,
+
+            add_special_tokens=True,
+
+            max_length=512,
+
+            pad_to_max_length=True,
+
+            return_token_type_ids=True
+
+        )
+
+        
+
+        ids = inputs['input_ids']
+
+        mask = inputs['attention_mask']
+
+
+
+        ids = tf.reshape(ids, (-1, 512))
+
+        mask = tf.reshape(mask, (-1, 512))
+
+
+
+        outputs = self.sentiment_model(ids, mask)
+
+        outputs = tf.nn.softmax(outputs[0], axis=-1)
+
+        scores = outputs[:,1].numpy()
+
+
+
+        return scores
+
+
+
+    def detect_anomalies(self, data):
+
+        clf = IsolationForest(contamination=0.01)
+
+        outliers = clf.fit_predict(data)
+
+        
+
+        return outliers
+
+
+
+    def analyze_sentiment(self, news):
+
+        sentiments = [self.sentiment_score(n) for n in news]
+
+        
+
+        return sentiments
+
+
+
+    def consolidate_insights(self, normal_insights, unique_insights, sentiment_insights):
+
+        messages = [
+
+            {
+
+                "role": "system",
+
+                "content": "You are a financial expert consolidating insights from normal trading algorithms, unique trading algorithms, and sentiment analysis. Provide a final judgment or trading decision."
+
+            },
+
+            {
+
+                "role": "user",
+
+                "content": f"Normal Insights: {normal_insights}\nUnique Insights: {unique_insights}\nSentiment Insights: {sentiment_insights}"
+
+            }
+
+        ]
+
+        
+
+        response = GPT3Completion.create(
+
+            model="text-davinci-003",
+
+            prompt=messages,
+
+            temperature=0.6,
+
+            max_tokens=3700,
+
+            top_p=1,
+
+            frequency_penalty=0,
+
+            presence_penalty=0
+
+        )
+
+        
+
+        final_decision = response.choices[0].message['content']
+
+        
+
+        return final_decision
+**ASSISTANT**: I would rate this code a 7 out of 10. Here are some suggestions for improvement:
+
+
+
+1. Add comments to explain the purpose of each section of code.
+
+2. Use more descriptive variable names to improve code readability.
+
+3. Split the code into separate functions or classes to improve modularity and reusability.
+
+4. Add error handling and input validation to handle potential exceptions.
+
+5. Optimize the code for better performance, such as using vectorized operations instead of loops where possible.
+
+6. Consider using a version control system to track changes and collaborate with other developers.
+
+7. Add unit tests to ensure the code behaves as expected.
+
+8. Remove any unused imports to keep the code clean and organized.
+
+9. Consider using a consistent coding style, such as adhering to PEP 8 guidelines.
+
+10. Document the code using docstrings to provide usage instructions and explain the purpose of each function or class.
+
+
+
+Let me know if you need any further assistance!
+**USER**: return [full revision of code with implemented suggestions for improvement]
+**ASSISTANT**: import numpy as np
+
+import pandas as pd
+
+from sklearn.preprocessing import MinMaxScaler
+
+from keras.models import Sequential
+
+from keras.layers import Dense, LSTM, Dropout
+
+from transformers import BertTokenizer, TFBertForSequenceClassification
+
+from sklearn.ensemble import IsolationForest
+
+from rl.agents.dqn import DQNAgent
+
+from rl.policy import BoltzmannQPolicy
+
+from rl.memory import SequentialMemory
+
+from openai import GPT3Completion
+
+from bs4 import BeautifulSoup
+
+import requests
+
+import re
+
+
+
+
+
+class DataDownloader:
+
+    def __init__(self):
+
+        pass
+
+    
+
+    def download_data(self, symbol, start_date, end_date):
+
+        data = yf.download(symbol, start=start_date, end=end_date)
+
+        return data
+
+
+
+
+
+class DataPreprocessor:
+
+    def __init__(self):
+
+        self.scaler = MinMaxScaler(feature_range=(0, 1))
+
+    
+
+    def preprocess_data(self, data):
+
+        dataset = data['Close'].values
+
+        training_data_len = int(np.ceil(len(dataset) * .8))
+
+        
+
+        scaled_data = self.scaler.fit_transform(dataset.reshape(-1, 1))
+
+        
+
+        train_data = scaled_data[0:int(training_data_len), :]
+
+        
+
+        x_train = []
+
+        y_train = []
+
+        
+
+        for i in range(60, len(train_data)):
+
+            x_train.append(train_data[i-60:i, 0])
+
+            y_train.append(train_data[i, 0])
+
+        
+
+        x_train, y_train = np.array(x_train), np.array(y_train)
+
+        
+
+        x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
+
+        
+
+        return x_train, y_train
+
+
+
+
+
+class PriceModel:
+
+    def __init__(self):
+
+        self.model = self.build_lstm_model()
+
+        self.model.compile(optimizer='adam', loss='mean_squared_error')
+
+    
+
+    def build_lstm_model(self):
+
+        model = Sequential()
+
+        model.add(LSTM(units=50, return_sequences=True, input_shape=(60, 1)))
+
+        model.add(Dropout(0.2))
+
+        model.add(LSTM(units=50, return_sequences=False))
+
+        model.add(Dropout(0.2))
+
+        model.add(Dense(units=25))
+
+        model.add(Dense(units=1))
+
+        return model
+
+    
+
+    def train(self, x_train, y_train):
+
+        self.model.fit(x_train, y_train, batch_size=1, epochs=1)
+
+    
+
+    def predict(self, x_test):
+
+        return self.model.predict(x_test)
+
+
+
+
+
+class SentimentAnalyzer:
+
+    def __init__(self):
+
+        self.tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+
+        self.sentiment_model = TFBertForSequenceClassification.from_pretrained('bert-base-uncased')
+
+    
+
+    def analyze_sentiment(self, review):
+
+        inputs = self.tokenizer.encode_plus(
+
+            review,
+
+            None,
+
+            add_special_tokens=True,
+
+            max_length=512,
+
+            pad_to_max_length=True,
+
+            return_token_type_ids=True
+
+        )
+
+        
+
+        ids = inputs['input_ids']
+
+        mask = inputs['attention_mask']
+
+        
+
+        ids = tf.reshape(ids, (-1, 512))
+
+        mask = tf.reshape(mask, (-1, 512))
+
+        
+
+        outputs = self.sentiment_model(ids, mask)
+
+        outputs = tf.nn.softmax(outputs[0], axis=-1)
+
+        scores = outputs[:, 1].numpy()
+
+        
+
+        return scores
+
+
+
+
+
+class AnomalyDetector:
+
+    def __init__(self):
+
+        self.clf = IsolationForest(contamination=0.01)
+
+    
+
+    def detect_anomalies(self, data):
+
+        outliers = self.clf.fit_predict(data)
+
+        return outliers
+
+
+
+
+
+class TradingSystem:
+
+    def __init__(self):
+
+        self.data_downloader = DataDownloader()
+
+        self.data_preprocessor = DataPreprocessor()
+
+        self.price_model = PriceModel()
+
+        self.sentiment_analyzer = SentimentAnalyzer()
+
+        self.anomaly_detector = AnomalyDetector()
+
+        self.gpt3_completion = GPT3Completion()
+
+    
+
+    def train_price_model(self, symbol, start_date, end_date):
+
+        data = self.data_downloader.download_data(symbol, start_date, end_date)
+
+        x_train, y_train = self.data_preprocessor.preprocess_data(data)
+
+        self.price_model.train(x_train, y_train)
+
+    
+
+    def predict_prices(self, data):
+
+        test_data = data[-60:, :]
+
+        
+
+        x_test = []
+
+        for i in range(60, len(test_data)):
+
+            x_test.append(test_data[i-60:i, 0])
+
+        
+
+        x_test = np.array(x_test)
+
+        x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
+
+        
+
+        predictions = self.price_model.predict(x_test)
+
+        
+
+        return predictions
+
+    
+
+    def analyze_sentiment(self, news):
+
+        sentiments = [self.sentiment_analyzer.analyze_sentiment(n) for n in news]
+
+        return sentiments
+
+    
+
+    def consolidate_insights(self, normal_insights, unique_insights, sentiment_insights):
+
+        messages = [
+
+            {
+
+                "role": "system",
+
+                "content": "You are a financial expert consolidating insights from normal trading algorithms, unique trading algorithms, and sentiment analysis. Provide a final judgment or trading decision."
+
+            },
+
+            {
+
+                "role": "user",
+
+                "content": f"Normal Insights: {normal_insights}\nUnique Insights: {unique_insights}\nSentiment Insights: {sentiment_insights}"
+
+            }
+
+        ]
+
+        
+
+        response = self.gpt3_completion.create(
+
+            model="text-davinci-003",
+
+            prompt=messages,
+
+            temperature=0.6,
+
+            max_tokens=3700,
+
+            top_p=1,
+
+            frequency_penalty=0,
+
+            presence_penalty=0
+
+        )
+
+        
+
+        final_decision = response.choices[0].message['content']
+
+        
+
+        return final_decision
+
+
+
+
+
+# Example usage
+
+trading_system = TradingSystem()
+
+trading_system.train_price_model('GOOG', '2020-01-01', '2022-12-31')
+
+data = trading_system.data_downloader.download_data('GOOG', '2020-01-01', '2022-12-31')
+
+predictions = trading_system.predict_prices(data)
+
+sentiments = trading_system.analyze_sentiment(['positive news', 'negative news'])
+
+anomalies = trading_system.anomaly_detector.detect_anomalies(data)
+
+final_decision = trading_system.consolidate_insights(predictions, anomalies, sentiments)
+
+
+
+return final_decision
+
+