update finr

app.py

@@ -43,16 +43,29 @@ if submit:
                 history['EMA9'] = utils.calculate_ema(history, 9)
                 history['VWAP'] = utils.calculate_vwap(history)
                 
-                # Khởi tạo và huấn luyện mô hình RL
-                rl_trader = RLTrader()
-                rl_trader.train(history)
+                # Chuẩn bị dữ liệu cho mô hình RL
+                history_for_rl = history.copy()
+                # Chuyển đổi tất cả các cột số sang float64
+                numeric_columns = ['close', 'volume', 'RSI', 'MACD', 'Signal', 'EMA20', 'EMA50']
+                for col in numeric_columns:
+                    history_for_rl[col] = pd.to_numeric(history_for_rl[col], errors='coerce')
                 
-                # Dự đoán tín hiệu giao dịch và lấy hiệu suất
-                rl_signals, performance = rl_trader.predict(history)
+                # Kiểm tra và xử lý missing values
+                history_for_rl = history_for_rl.fillna(method='ffill')
                 
-                # Thêm tín hiệu RL vào history và lưu thông tin hiệu suất
-                history = pd.concat([history, rl_signals], axis=1)
-                history.attrs.update(performance)
+                # Khởi tạo và huấn luyện mô hình RL
+                try:
+                    rl_trader = RLTrader()
+                    rl_trader.train(history_for_rl)
+                    
+                    # Dự đoán tín hiệu giao dịch và lấy hiệu suất
+                    rl_signals, performance = rl_trader.predict(history_for_rl)
+                    
+                    # Thêm tín hiệu RL vào history và lưu thông tin hiệu suất
+                    history = pd.concat([history, rl_signals], axis=1)
+                    history.attrs.update(performance)
+                except Exception as e:
+                    st.error(f"Lỗi trong quá trình huấn luyện mô hình RL: {str(e)}")
                 
                 # Tạo tín hiệu giao dịch
                 signals = utils.generate_rsi_macd_signals(history)

finrl_agent.py

@@ -38,16 +38,17 @@ class StockTradingEnv(gym.Env):
         return self._next_observation(), {}
         
     def _next_observation(self):
+        # Chuyển đổi các giá trị sang float64 trước khi tạo array
         obs = np.array([
-            self.df['close'].iloc[self.current_step],
-            self.df['volume'].iloc[self.current_step],
-            self.df['RSI'].iloc[self.current_step],
-            self.df['MACD'].iloc[self.current_step],
-            self.df['Signal'].iloc[self.current_step],
-            self.df['EMA20'].iloc[self.current_step],
-            self.df['EMA50'].iloc[self.current_step]
-        ])
-        return obs.astype(np.float32)
+            float(self.df['close'].iloc[self.current_step]),
+            float(self.df['volume'].iloc[self.current_step]),
+            float(self.df['RSI'].iloc[self.current_step]),
+            float(self.df['MACD'].iloc[self.current_step]),
+            float(self.df['Signal'].iloc[self.current_step]),
+            float(self.df['EMA20'].iloc[self.current_step]),
+            float(self.df['EMA50'].iloc[self.current_step])
+        ], dtype=np.float32)
+        return obs
         
     def step(self, action):
         current_price = self.df['close'].iloc[self.current_step]
@@ -94,8 +95,16 @@ class RLTrader:
         
     def train(self, df):
         """Huấn luyện mô hình RL"""
+        # Kiểm tra dữ liệu đầu vào
+        if not all(col in df.columns for col in ['close', 'volume', 'RSI', 'MACD', 'Signal', 'EMA20', 'EMA50']):
+            raise ValueError("Thiếu một số cột dữ liệu cần thiết cho mô hình RL")
+            
+        # Kiểm tra giá trị NaN
+        if df[['close', 'volume', 'RSI', 'MACD', 'Signal', 'EMA20', 'EMA50']].isna().any().any():
+            raise ValueError("Dữ liệu chứa giá trị NaN")
+            
         # Tạo môi trường
-        env = DummyVecEnv([lambda: StockTradingEnv(df)])
+        env = DummyVecEnv([lambda: StockTradingEnv(df.copy())])
         
         # Khởi tạo và huấn luyện mô hình
         self.model = PPO("MlpPolicy", env, verbose=0,
@@ -115,12 +124,24 @@ class RLTrader:
         obs = env.reset()[0]
         
         actions = []
-        for _ in range(len(df)):
+        states = []
+        current_step = 0
+        
+        while current_step < len(df):
             action, _ = self.model.predict(obs, deterministic=True)
             actions.append(action)
+            states.append(obs)
             obs, _, done, _, _ = env.step(action)
+            current_step += 1
             if done:
+                # Nếu đã kết thúc nhưng chưa đủ độ dài, thêm hành động giữ
+                while current_step < len(df):
+                    actions.append(1)  # 1 = Giữ
+                    current_step += 1
                 break
+                
+        # Đảm bảo độ dài của actions bằng với độ dài của DataFrame
+        actions = actions[:len(df)]
         
         # Chuyển đổi actions thành tín hiệu
         signals = pd.DataFrame({

requirements.txt

@@ -25,7 +25,7 @@ kiwisolver==1.4.8
 MarkupSafe==3.0.2
 matplotlib==3.10.1
 narwhals==1.32.0
-numpy==2.2.4
+numpy==1.26.4
 openpyxl==3.1.5
 packaging==24.2
 pandas==2.2.3

ui.py

@@ -499,7 +499,7 @@ def display_signals(history, stock_symbol):
             'RSI': buy_signals['RSI'].round(2),
             'MACD': buy_signals['MACD'].round(2)
         })
-        timeline_df = pd.concat([timeline_df, buy_df])
+        timeline_df = pd.concat([timeline_df, buy_df], ignore_index=True)
     
     # Thêm tín hiệu bán
     if not sell_signals.empty:
@@ -510,7 +510,7 @@ def display_signals(history, stock_symbol):
             'RSI': sell_signals['RSI'].round(2),
             'MACD': sell_signals['MACD'].round(2)
         })
-        timeline_df = pd.concat([timeline_df, sell_df])
+        timeline_df = pd.concat([timeline_df, sell_df], ignore_index=True)
     
     # Sắp xếp theo ngày
     if not timeline_df.empty:
@@ -587,15 +587,21 @@ def display_signals(history, stock_symbol):
     
     with signals_tab2:
         if not sell_signals.empty:
-            sell_signals_display = sell_signals[['time', 'close', 'RSI', 'MACD', 'Signal']].rename(
-                columns={
-                    'time': 'Ngày',
-                    'close': 'Giá đóng cửa',
-                    'RSI': 'RSI',
-                    'MACD': 'MACD',
-                    'Signal': 'Signal'
-                }
-            )
+            sell_signals_display = sell_signals[['time', 'close', 'RSI', 'MACD', 'Signal']].copy()
+            # Chuyển đổi dữ liệu số sang float
+            numeric_cols = ['close', 'RSI', 'MACD', 'Signal']
+            sell_signals_display[numeric_cols] = sell_signals_display[numeric_cols].apply(pd.to_numeric, errors='coerce')
+            
+            sell_signals_display = sell_signals_display.rename(columns={
+                'time': 'Ngày',
+                'close': 'Giá đóng cửa',
+                'RSI': 'RSI',
+                'MACD': 'MACD',
+                'Signal': 'Signal'
+            })
+            
+            # Format số trước khi hiển thị
+            sell_signals_display['Giá đóng cửa'] = sell_signals_display['Giá đóng cửa'].map('{:,.0f}'.format)
             st.dataframe(sell_signals_display, use_container_width=True)
         else:
             st.info("Không có tín hiệu BÁN trong khoảng thời gian này.")
@@ -948,13 +954,15 @@ def display_rl_analysis(history, stock_symbol):
     
     # Hiển thị danh sách tín hiệu gần đây
     st.subheader("Tín hiệu gần đây từ mô hình RL")
-    recent_signals = history[['time', 'close', 'RL_Signal', 'RL_Action']].tail(10)
+    recent_signals = history[['time', 'close', 'RL_Signal', 'RL_Action']].tail(10).copy()
     recent_signals = recent_signals.rename(columns={
         'time': 'Thời gian',
         'close': 'Giá đóng cửa',
         'RL_Signal': 'Tín hiệu',
         'RL_Action': 'Hành động'
     })
+    # Đảm bảo kiểu dữ liệu trước khi định dạng
+    recent_signals['Giá đóng cửa'] = pd.to_numeric(recent_signals['Giá đóng cửa'], errors='coerce')
     st.dataframe(recent_signals.style.format({
         'Giá đóng cửa': '{:,.0f}'
     }))

utils.py

@@ -12,17 +12,32 @@ def calculate_rsi(data, period=14):
     Returns:
         Series: Series chứa giá trị RSI
     """
-    delta = data['close'].diff()
-    gain = delta.where(delta > 0, 0)
-    loss = -delta.where(delta < 0, 0)
-    
-    avg_gain = gain.rolling(window=period).mean()
-    avg_loss = loss.rolling(window=period).mean()
-    
-    rs = avg_gain / avg_loss
-    rsi = 100 - (100 / (1 + rs))
-    
-    return rsi
+    try:
+        # Chuyển đổi dữ liệu sang float
+        close_prices = pd.to_numeric(data['close'], errors='coerce')
+        
+        delta = close_prices.diff()
+        gain = delta.where(delta > 0, 0)
+        loss = -delta.where(delta < 0, 0)
+        
+        avg_gain = gain.rolling(window=period).mean()
+        avg_loss = loss.rolling(window=period).mean()
+        
+        # Tránh chia cho 0
+        # Thay thế giá trị 0 trong avg_loss bằng np.inf
+        avg_loss = np.where(avg_loss == 0, np.inf, avg_loss)
+        rs = avg_gain / avg_loss
+        rsi = 100 - (100 / (1 + rs))
+        
+        # Xử lý các giá trị không hợp lệ
+        rsi = rsi.fillna(50)  # Giá trị trung tính cho RSI
+        rsi = rsi.clip(0, 100)  # Giới hạn giá trị trong khoảng [0, 100]
+        
+        return rsi.astype(np.float32)
+        
+    except Exception as e:
+        print(f"Lỗi khi tính RSI: {str(e)}")
+        return pd.Series(index=data.index, dtype=np.float32)
 
 
 def calculate_macd(data, fast_period=12, slow_period=26, signal_period=9):
@@ -38,12 +53,25 @@ def calculate_macd(data, fast_period=12, slow_period=26, signal_period=9):
     Returns:
         tuple: (MACD, Signal)
     """
-    exp1 = data['close'].ewm(span=fast_period, adjust=False).mean()
-    exp2 = data['close'].ewm(span=slow_period, adjust=False).mean()
-    macd = exp1 - exp2
-    signal = macd.ewm(span=signal_period, adjust=False).mean()
-    
-    return macd, signal
+    try:
+        # Chuyển đổi dữ liệu sang float
+        close_prices = pd.to_numeric(data['close'], errors='coerce')
+        
+        exp1 = close_prices.ewm(span=fast_period, adjust=False).mean()
+        exp2 = close_prices.ewm(span=slow_period, adjust=False).mean()
+        macd = exp1 - exp2
+        signal = macd.ewm(span=signal_period, adjust=False).mean()
+        
+        # Xử lý các giá trị không hợp lệ
+        macd = macd.ffill().fillna(0)
+        signal = signal.ffill().fillna(0)
+        
+        return macd.astype(np.float32), signal.astype(np.float32)
+        
+    except Exception as e:
+        print(f"Lỗi khi tính MACD: {str(e)}")
+        empty_series = pd.Series(index=data.index, dtype=np.float32)
+        return empty_series, empty_series
 
 
 def calculate_ema(data, period):
@@ -57,7 +85,13 @@ def calculate_ema(data, period):
     Returns:
         Series: Series chứa giá trị EMA
     """
-    return data['close'].ewm(span=period, adjust=False).mean()
+    try:
+        close_prices = pd.to_numeric(data['close'], errors='coerce')
+        ema = close_prices.ewm(span=period, adjust=False).mean()
+        return ema.fillna(method='ffill').fillna(0).astype(np.float32)
+    except Exception as e:
+        print(f"Lỗi khi tính EMA: {str(e)}")
+        return pd.Series(index=data.index, dtype=np.float32)
 
 
 def calculate_ema9(data):
@@ -85,12 +119,27 @@ def calculate_bollinger_bands(data, period=20, std_dev=2):
     Returns:
         tuple: (Upper Band, Middle Band, Lower Band)
     """
-    middle_band = data['close'].rolling(window=period).mean()
-    std = data['close'].rolling(window=period).std()
-    upper_band = middle_band + (std_dev * std)
-    lower_band = middle_band - (std_dev * std)
-    
-    return upper_band, middle_band, lower_band
+    try:
+        # Chuyển đổi dữ liệu sang float
+        close_prices = pd.to_numeric(data['close'], errors='coerce')
+        
+        middle_band = close_prices.rolling(window=period).mean()
+        std = close_prices.rolling(window=period).std()
+        upper_band = middle_band + (std_dev * std)
+        lower_band = middle_band - (std_dev * std)
+        
+        # Xử lý các giá trị không hợp lệ
+        middle_band = middle_band.ffill().fillna(0)
+        upper_band = upper_band.ffill().fillna(0)
+        lower_band = lower_band.ffill().fillna(0)
+        
+        return (upper_band.astype(np.float32),
+                middle_band.astype(np.float32),
+                lower_band.astype(np.float32))
+    except Exception as e:
+        print(f"Lỗi khi tính Bollinger Bands: {str(e)}")
+        empty_series = pd.Series(index=data.index, dtype=np.float32)
+        return empty_series, empty_series, empty_series
 
 
 def calculate_vwap(data):
@@ -103,9 +152,22 @@ def calculate_vwap(data):
     Returns:
         Series: Series chứa giá trị VWAP
     """
-    typical_price = (data['high'] + data['low'] + data['close']) / 3
-    vwap = (typical_price * data['volume']).cumsum() / data['volume'].cumsum()
-    return vwap
+    try:
+        # Chuyển đổi dữ liệu sang float
+        high = pd.to_numeric(data['high'], errors='coerce')
+        low = pd.to_numeric(data['low'], errors='coerce')
+        close = pd.to_numeric(data['close'], errors='coerce')
+        volume = pd.to_numeric(data['volume'], errors='coerce')
+        
+        typical_price = (high + low + close) / 3
+        vwap = (typical_price * volume).cumsum() / volume.cumsum()
+        
+        # Xử lý các giá trị không hợp lệ
+        vwap = vwap.ffill().bfill()
+        return vwap.astype(np.float32)
+    except Exception as e:
+        print(f"Lỗi khi tính VWAP: {str(e)}")
+        return pd.Series(index=data.index, dtype=np.float32)
 
 
 def generate_rsi_macd_signals(data):
@@ -118,38 +180,61 @@ def generate_rsi_macd_signals(data):
     Returns:
         DataFrame: DataFrame chứa tín hiệu mua/bán
     """
-    signals = pd.DataFrame(index=data.index)
-    
-    # RSI Signals
-    signals['RSI_Buy'] = ((data['RSI'] < 30) & (data['RSI'].shift(1) >= 30))
-    signals['RSI_Sell'] = ((data['RSI'] > 70) & (data['RSI'].shift(1) <= 70))
-    
-    # MACD Signals
-    signals['MACD_Buy'] = ((data['MACD'] > data['Signal']) & 
-                          (data['MACD'].shift(1) <= data['Signal'].shift(1)))
-    signals['MACD_Sell'] = ((data['MACD'] < data['Signal']) & 
-                           (data['MACD'].shift(1) >= data['Signal'].shift(1)))
-    
-    # EMA Signals
-    signals['EMA_Buy'] = ((data['close'] > data['EMA50']) & 
-                         (data['close'].shift(1) <= data['EMA50'].shift(1)))
-    signals['EMA_Sell'] = ((data['close'] < data['EMA50']) & 
-                          (data['close'].shift(1) >= data['EMA50'].shift(1)))
-    
-    # Bollinger Bands Signals
-    signals['BB_Buy'] = (data['close'] < data['BB_Lower'])
-    signals['BB_Sell'] = (data['close'] > data['BB_Upper'])
-    
-    # Combined Signals - more conservative approach (require multiple indicators)
-    signals['Strong_Buy'] = ((signals['RSI_Buy'] & signals['MACD_Buy']) | 
-                            (signals['MACD_Buy'] & signals['EMA_Buy']) |
-                            (signals['RSI_Buy'] & signals['BB_Buy']))
-    
-    signals['Strong_Sell'] = ((signals['RSI_Sell'] & signals['MACD_Sell']) | 
-                             (signals['MACD_Sell'] & signals['EMA_Sell']) |
-                             (signals['RSI_Sell'] & signals['BB_Sell']))
-    
-    return signals
+    try:
+        # Kiểm tra các cột cần thiết
+        required_columns = ['RSI', 'MACD', 'Signal', 'close', 'EMA50', 'BB_Lower', 'BB_Upper']
+        if not all(col in data.columns for col in required_columns):
+            raise ValueError("Thiếu một số cột dữ liệu cần thiết cho việc tạo tín hiệu")
+
+        # Chuyển đổi dữ liệu sang float
+        signals_data = data[required_columns].apply(pd.to_numeric, errors='coerce')
+        
+        signals = pd.DataFrame(index=data.index)
+        
+        # RSI Signals với kiểm tra giá trị hợp lệ
+        signals['RSI_Buy'] = ((signals_data['RSI'] < 30) & (signals_data['RSI'].shift(1) >= 30)).fillna(False)
+        signals['RSI_Sell'] = ((signals_data['RSI'] > 70) & (signals_data['RSI'].shift(1) <= 70)).fillna(False)
+        
+        # MACD Signals với kiểm tra giá trị hợp lệ
+        signals['MACD_Buy'] = ((signals_data['MACD'] > signals_data['Signal']) &
+                              (signals_data['MACD'].shift(1) <= signals_data['Signal'].shift(1))).fillna(False)
+        signals['MACD_Sell'] = ((signals_data['MACD'] < signals_data['Signal']) &
+                               (signals_data['MACD'].shift(1) >= signals_data['Signal'].shift(1))).fillna(False)
+        
+        # EMA Signals với kiểm tra giá trị hợp lệ
+        signals['EMA_Buy'] = ((signals_data['close'] > signals_data['EMA50']) &
+                             (signals_data['close'].shift(1) <= signals_data['EMA50'].shift(1))).fillna(False)
+        signals['EMA_Sell'] = ((signals_data['close'] < signals_data['EMA50']) &
+                              (signals_data['close'].shift(1) >= signals_data['EMA50'].shift(1))).fillna(False)
+        
+        # Bollinger Bands Signals với kiểm tra giá trị hợp lệ
+        signals['BB_Buy'] = (signals_data['close'] < signals_data['BB_Lower']).fillna(False)
+        signals['BB_Sell'] = (signals_data['close'] > signals_data['BB_Upper']).fillna(False)
+        
+        # Combined Signals với kiểm tra giá trị hợp lệ
+        signals['Strong_Buy'] = ((signals['RSI_Buy'] & signals['MACD_Buy']) |
+                                (signals['MACD_Buy'] & signals['EMA_Buy']) |
+                                (signals['RSI_Buy'] & signals['BB_Buy']))
+        
+        signals['Strong_Sell'] = ((signals['RSI_Sell'] & signals['MACD_Sell']) |
+                                 (signals['MACD_Sell'] & signals['EMA_Sell']) |
+                                 (signals['RSI_Sell'] & signals['BB_Sell']))
+        
+        # Đảm bảo không có tín hiệu mua và bán đồng thời
+        signals.loc[signals['Strong_Buy'] & signals['Strong_Sell'], 'Strong_Buy'] = False
+        
+        return signals
+        
+    except Exception as e:
+        print(f"Lỗi khi tạo tín hiệu giao dịch: {str(e)}")
+        # Trả về DataFrame trống với các cột tín hiệu
+        empty_signals = pd.DataFrame(index=data.index)
+        signal_columns = ['RSI_Buy', 'RSI_Sell', 'MACD_Buy', 'MACD_Sell',
+                         'EMA_Buy', 'EMA_Sell', 'BB_Buy', 'BB_Sell',
+                         'Strong_Buy', 'Strong_Sell']
+        for col in signal_columns:
+            empty_signals[col] = False
+        return empty_signals
 
 
 def calculate_performance(data):
@@ -173,7 +258,7 @@ def calculate_performance(data):
     data.loc[data['Strong_Sell'], 'Position'] = 0
     
     # Forward fill: giữ vị thế cho đến khi có tín hiệu ngược lại
-    data['Position'] = data['Position'].replace(to_replace=0, method='ffill')
+    data['Position'] = data['Position'].ffill().fillna(0)
     
     # Tính toán lợi nhuận theo ngày
     data['Returns'] = data['close'].pct_change()