model.save(model_path) has error when the file size exceed the 773Kb.

[howtokim]

bellow source program has no problem to be saved at normal.
but, if the file size exceed the 773K bytes.
the program is stopped at the line "model.save(model_save_path)"
there wa no except message. just stopped at the line.

<< source program>>
ticker = ticker.replace('KRW-', '')
# 매수 의견을 기록할 리스트 초기화
self.acc_reward_cnt = 0
self.acc_action_cnt = 0

if ticker_name:
   self.ticker_count += 1
   stockName = ticker_name
   print(f"{stockName}({ticker}) 강화학습 모델 Training 시작({self.ticker_count}/{len(coin_list)})...")

   chart_intervals = 'minute5'
   current_time = self.current_datetime_str
   chart_data = self.save_db_market_infos(ticker=ticker, chart_intervals=chart_intervals, current_time=current_time)
   if chart_data is None:
       continue
   chart_data.set_index('time', inplace=True)
   predict_time = chart_data.index[-1]

   if chart_data is not None:
        strategy_chart_data = self.calculate_indicators(chart_data, ticker)
        strategy_chart_data_df = pd.DataFrame([strategy_chart_data])
        train_data, test_data = train_test_split(chart_data, test_size=0.2, shuffle=False)

        model = self.train_model(train_data)
        total_rewards = self.evaluate_model(model, test_data)
        print(f"total_rewards: {total_rewards}")
        print(f"self.acc_reward_cnt: {self.acc_reward_cnt}")
        print(f"self.acc_action_cnt: {self.acc_action_cnt}")
        try:
            self.predict_ratio = np.round(self.acc_reward_cnt / self.acc_action_cnt * 100, 1)
            print(f"predict_ratio: {self.predict_ratio}")
        except:
            self.predict_ratio = 0

        if isinstance(strategy_chart_data_df, pd.DataFrame):
            obs = strategy_chart_data_df.values.flatten().astype(np.float32)
            obs = np.expand_dims(obs, axis=0)
            action, _states = model.predict(obs)
            if action == 1:
                print("purchase: Yes")
            else:
                print("purchase: No")
        else:
            print("Error: chart_data is not a DataFrame")
    else:
        print("Error: chart_data is None")

def train_model(self, data):
    self.env = DummyVecEnv([lambda: TradingEnv(data)])
    try:
        print("Loading or creating model...")
        model = self.load_or_create_model()
        print("Model loaded or created successfully.")

        print("Setting environment for the model.")
        model.set_env(self.env)
        print("Environment set successfully.")

        print("Starting model training...")
        model.learn(total_timesteps=10000)
        print("Model training completed.")

        print("Saving model...")
        self.save_model(model)
        print("Model saved successfully.")

        self.cleanup_old_backups()
    except Exception as e:
        print(f"An error occurred during model training: {e}")
    return model

def load_latest_backup(self):
    """load the model from backup file"""
    if not os.path.exists(self.backup_dir):
        os.makedirs(self.backup_dir)
    else:
        backup_files = sorted(
            [os.path.join(self.backup_dir, f) for f in os.listdir(self.backup_dir)],
            key=os.path.getmtime,
            reverse=True
        )

    for backup_file in backup_files:
        if os.path.getsize(backup_file) > 0:
            print(f"Loading backup model from {backup_file}")
            return PPO.load(backup_file)
    print("No valid backup found. Initializing a new model.")
    return self.create_new_model()
    # model = PPO('MlpPolicy', self.env, verbose=0)  # 새 모델 초기화
    return model

def create_new_model(self):
    return PPO(
        'MlpPolicy',
        env=self.env,  # 실제 환경을 이곳에 전달해야 합니다.
        verbose=0,
        n_steps=128, # Number of steps to run for each environment per update
        batch_size=64, # Mini batch size
        n_epochs=10, # Number of epoch when optimizing the surrogate loss
        gamma=0.99, # Discount factor
        learning_rate=0.001, # Learning rate
        clip_range=0.2, # Clipping parameter, it can be a function
        ent_coef=0.05, # Entropy coefficient for the loss calculation
    )

def save_model(self, model):
    """모델을 저장하고 백업을 생성합니다."""
    try:
        print("Attempting to save the model...")
        timestamp = time.strftime("%Y%m%d-%H%M%S")
        model_save_path = f"{self.model_path}.model"  # 확장자를 .zip 대신 .model로 변경
        print(model_save_path)
        # model_save_path = os.path.abspath(model_save_path)
        try:
            model.save(model_save_path)
            print(f"Model saved successfully at {model_save_path}")
        except Exception as e:
            print(f"Error while saving model: {e}")
        # 백업 디렉토리로 복사
        model_backup_path = f"{self.model_path}_{timestamp}.model"  # 확장자를 .zip 대신 .model로 변경
        backup_save_path = os.path.join("model_backups", os.path.basename(model_backup_path))
        shutil.copy(model_save_path, backup_save_path)
        print(f"Backup saved successfully at {backup_save_path}")
    except Exception as e:
        print(f"Failed to save model: {e}")

I checked the disk's free space and folder size.
and also check the CPU and Memory during the program is running.
it seems there is nothing problem.