1095 lines
44 KiB
C#
1095 lines
44 KiB
C#
using System.Text.Json;
|
|
using GeneticSharp;
|
|
using Managing.Application.Abstractions.Repositories;
|
|
using Managing.Application.Abstractions.Services;
|
|
using Managing.Application.Backtests;
|
|
using Managing.Core;
|
|
using Managing.Domain.Backtests;
|
|
using Managing.Domain.Bots;
|
|
using Managing.Domain.Candles;
|
|
using Managing.Domain.MoneyManagements;
|
|
using Managing.Domain.Risk;
|
|
using Managing.Domain.Scenarios;
|
|
using Managing.Domain.Strategies;
|
|
using Managing.Domain.Users;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.Logging;
|
|
using static Managing.Common.Enums;
|
|
|
|
namespace Managing.Application;
|
|
|
|
/// <summary>
|
|
/// Service implementation for managing genetic algorithm requests
|
|
/// </summary>
|
|
public class GeneticService : IGeneticService
|
|
{
|
|
private readonly IGeneticRepository _geneticRepository;
|
|
private readonly IBacktester _backtester;
|
|
private readonly ILogger<GeneticService> _logger;
|
|
private readonly IMessengerService _messengerService;
|
|
private readonly IServiceScopeFactory _serviceScopeFactory;
|
|
private readonly IGrainFactory _grainFactory;
|
|
private readonly IJobRepository _jobRepository;
|
|
|
|
// Predefined parameter ranges for each indicator (matching backtestGenetic.tsx)
|
|
public static readonly Dictionary<string, (double min, double max)> ParameterRanges = new()
|
|
{
|
|
// Trading Parameters only - indicator parameters are now handled by IndicatorParameterRanges
|
|
["stopLoss"] = (0.2, 50.0), // Minimum 0.2% to cover fees, no upper limit (set to 50% as practical max)
|
|
["leverage"] = (1.0, 10.0),
|
|
["cooldownPeriod"] = (5.0, 25.0),
|
|
["maxLossStreak"] = (0.0, 4.0),
|
|
["maxPositionTimeHours"] = (0, 48.0)
|
|
};
|
|
|
|
// Default indicator values per indicator type (matching CustomScenario.tsx)
|
|
public static readonly Dictionary<IndicatorType, Dictionary<string, double>> DefaultIndicatorValues = new()
|
|
{
|
|
[IndicatorType.RsiDivergence] = new() { ["period"] = 14.0 },
|
|
[IndicatorType.RsiDivergenceConfirm] = new() { ["period"] = 14.0 },
|
|
[IndicatorType.EmaCross] = new() { ["period"] = 14.0 },
|
|
[IndicatorType.EmaTrend] = new() { ["period"] = 14.0 },
|
|
[IndicatorType.StDev] = new() { ["period"] = 14.0 },
|
|
[IndicatorType.ThreeWhiteSoldiers] = new() { ["period"] = 14.0 },
|
|
[IndicatorType.MacdCross] = new()
|
|
{
|
|
["fastPeriods"] = 12.0,
|
|
["slowPeriods"] = 26.0,
|
|
["signalPeriods"] = 9.0
|
|
},
|
|
[IndicatorType.DualEmaCross] = new()
|
|
{
|
|
["fastPeriods"] = 12.0,
|
|
["slowPeriods"] = 26.0
|
|
},
|
|
[IndicatorType.SuperTrend] = new()
|
|
{
|
|
["period"] = 14.0,
|
|
["multiplier"] = 3.0
|
|
},
|
|
[IndicatorType.SuperTrendCrossEma] = new()
|
|
{
|
|
["period"] = 14.0,
|
|
["multiplier"] = 3.0
|
|
},
|
|
[IndicatorType.ChandelierExit] = new()
|
|
{
|
|
["period"] = 14.0,
|
|
["multiplier"] = 3.0
|
|
},
|
|
[IndicatorType.StochRsiTrend] = new()
|
|
{
|
|
["period"] = 14.0,
|
|
["stochPeriods"] = 14.0,
|
|
["signalPeriods"] = 9.0,
|
|
["smoothPeriods"] = 3.0
|
|
},
|
|
[IndicatorType.Stc] = new()
|
|
{
|
|
["cyclePeriods"] = 10.0,
|
|
["fastPeriods"] = 12.0,
|
|
["slowPeriods"] = 26.0
|
|
},
|
|
[IndicatorType.LaggingStc] = new()
|
|
{
|
|
["cyclePeriods"] = 10.0,
|
|
["fastPeriods"] = 12.0,
|
|
["slowPeriods"] = 26.0
|
|
}
|
|
};
|
|
|
|
// Indicator-specific parameter ranges
|
|
public static readonly Dictionary<IndicatorType, Dictionary<string, (double min, double max)>>
|
|
IndicatorParameterRanges = new()
|
|
{
|
|
[IndicatorType.RsiDivergence] = new()
|
|
{
|
|
["period"] = (6.0, 70.0)
|
|
},
|
|
[IndicatorType.RsiDivergenceConfirm] = new()
|
|
{
|
|
["period"] = (6.0, 70.0)
|
|
},
|
|
[IndicatorType.EmaCross] = new()
|
|
{
|
|
["period"] = (10.0, 300.0)
|
|
},
|
|
[IndicatorType.EmaTrend] = new()
|
|
{
|
|
["period"] = (10.0, 300.0)
|
|
},
|
|
[IndicatorType.StDev] = new()
|
|
{
|
|
["period"] = (5.0, 50.0)
|
|
},
|
|
[IndicatorType.ThreeWhiteSoldiers] = new()
|
|
{
|
|
["period"] = (5.0, 50.0)
|
|
},
|
|
[IndicatorType.MacdCross] = new()
|
|
{
|
|
["fastPeriods"] = (10.0, 70.0),
|
|
["slowPeriods"] = (20.0, 120.0),
|
|
["signalPeriods"] = (5.0, 50.0)
|
|
},
|
|
[IndicatorType.DualEmaCross] = new()
|
|
{
|
|
["fastPeriods"] = (5.0, 300.0),
|
|
["slowPeriods"] = (5.0, 300.0)
|
|
},
|
|
[IndicatorType.SuperTrend] = new()
|
|
{
|
|
["period"] = (5.0, 50.0),
|
|
["multiplier"] = (1.0, 10.0)
|
|
},
|
|
[IndicatorType.SuperTrendCrossEma] = new()
|
|
{
|
|
["period"] = (5.0, 50.0),
|
|
["multiplier"] = (1.0, 10.0)
|
|
},
|
|
[IndicatorType.ChandelierExit] = new()
|
|
{
|
|
["period"] = (5.0, 50.0),
|
|
["multiplier"] = (1.0, 10.0)
|
|
},
|
|
[IndicatorType.StochRsiTrend] = new()
|
|
{
|
|
["period"] = (5.0, 50.0),
|
|
["stochPeriods"] = (5.0, 30.0),
|
|
["signalPeriods"] = (3.0, 15.0),
|
|
["smoothPeriods"] = (1.0, 10.0)
|
|
},
|
|
[IndicatorType.Stc] = new()
|
|
{
|
|
["cyclePeriods"] = (5.0, 50.0),
|
|
["fastPeriods"] = (5.0, 70.0),
|
|
["slowPeriods"] = (10.0, 120.0)
|
|
},
|
|
[IndicatorType.LaggingStc] = new()
|
|
{
|
|
["cyclePeriods"] = (5.0, 30.0),
|
|
["fastPeriods"] = (5.0, 50.0),
|
|
["slowPeriods"] = (10.0, 100.0)
|
|
}
|
|
};
|
|
|
|
// Indicator type to parameter mapping
|
|
public static readonly Dictionary<IndicatorType, string[]> IndicatorParamMapping = new()
|
|
{
|
|
[IndicatorType.RsiDivergence] = ["period"],
|
|
[IndicatorType.RsiDivergenceConfirm] = ["period"],
|
|
[IndicatorType.EmaCross] = ["period"],
|
|
[IndicatorType.EmaTrend] = ["period"],
|
|
[IndicatorType.StDev] = ["period"],
|
|
[IndicatorType.ThreeWhiteSoldiers] = ["period"],
|
|
[IndicatorType.MacdCross] = ["fastPeriods", "slowPeriods", "signalPeriods"],
|
|
[IndicatorType.DualEmaCross] = ["fastPeriods", "slowPeriods"],
|
|
[IndicatorType.SuperTrend] = ["period", "multiplier"],
|
|
[IndicatorType.SuperTrendCrossEma] = ["period", "multiplier"],
|
|
[IndicatorType.ChandelierExit] = ["period", "multiplier"],
|
|
[IndicatorType.StochRsiTrend] = ["period", "stochPeriods", "signalPeriods", "smoothPeriods"],
|
|
[IndicatorType.Stc] = ["cyclePeriods", "fastPeriods", "slowPeriods"],
|
|
[IndicatorType.LaggingStc] = ["cyclePeriods", "fastPeriods", "slowPeriods"]
|
|
};
|
|
|
|
public GeneticService(
|
|
IGeneticRepository geneticRepository,
|
|
IBacktester backtester,
|
|
ILogger<GeneticService> logger,
|
|
IMessengerService messengerService,
|
|
IServiceScopeFactory serviceScopeFactory,
|
|
IGrainFactory grainFactory,
|
|
IJobRepository jobRepository)
|
|
{
|
|
_geneticRepository = geneticRepository;
|
|
_backtester = backtester;
|
|
_logger = logger;
|
|
_messengerService = messengerService;
|
|
_serviceScopeFactory = serviceScopeFactory;
|
|
_grainFactory = grainFactory;
|
|
_jobRepository = jobRepository;
|
|
}
|
|
|
|
public async Task<GeneticRequest> CreateGeneticRequestAsync(
|
|
User user,
|
|
Ticker ticker,
|
|
Timeframe timeframe,
|
|
DateTime startDate,
|
|
DateTime endDate,
|
|
decimal balance,
|
|
int populationSize,
|
|
int generations,
|
|
double mutationRate,
|
|
GeneticSelectionMethod selectionMethod,
|
|
GeneticCrossoverMethod crossoverMethod,
|
|
GeneticMutationMethod mutationMethod,
|
|
int elitismPercentage,
|
|
double maxTakeProfit,
|
|
List<IndicatorType> eligibleIndicators)
|
|
{
|
|
var id = Guid.NewGuid().ToString();
|
|
var geneticRequest = new GeneticRequest(id)
|
|
{
|
|
Ticker = ticker,
|
|
Timeframe = timeframe,
|
|
StartDate = startDate,
|
|
EndDate = endDate,
|
|
Balance = balance,
|
|
PopulationSize = populationSize,
|
|
Generations = generations,
|
|
MutationRate = mutationRate,
|
|
SelectionMethod = selectionMethod,
|
|
CrossoverMethod = crossoverMethod,
|
|
MutationMethod = mutationMethod,
|
|
ElitismPercentage = elitismPercentage,
|
|
MaxTakeProfit = maxTakeProfit,
|
|
EligibleIndicators = eligibleIndicators,
|
|
Status = GeneticRequestStatus.Pending
|
|
};
|
|
|
|
_geneticRepository.InsertGeneticRequestForUser(user, geneticRequest);
|
|
|
|
// Create a single job for this genetic request that will run until completion
|
|
try
|
|
{
|
|
var job = new Job
|
|
{
|
|
UserId = user.Id,
|
|
Status = JobStatus.Pending,
|
|
JobType = JobType.Genetic,
|
|
Priority = 0,
|
|
ConfigJson = "{}", // Not needed for genetic jobs, GeneticRequestId is used
|
|
StartDate = startDate,
|
|
EndDate = endDate,
|
|
GeneticRequestId = id,
|
|
RetryCount = 0,
|
|
MaxRetries = 3,
|
|
IsRetryable = true
|
|
};
|
|
|
|
await _jobRepository.CreateAsync(job);
|
|
_logger.LogInformation("Created genetic job {JobId} for genetic request {RequestId}", job.Id, id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to create job for genetic request {RequestId}", id);
|
|
throw;
|
|
}
|
|
|
|
return geneticRequest;
|
|
}
|
|
|
|
public IEnumerable<GeneticRequest> GetGeneticRequestsByUser(User user)
|
|
{
|
|
return _geneticRepository.GetGeneticRequestsByUser(user);
|
|
}
|
|
|
|
public GeneticRequest GetGeneticRequestByIdForUser(User user, string id)
|
|
{
|
|
return _geneticRepository.GetGeneticRequestByIdForUser(user, id);
|
|
}
|
|
|
|
public async Task UpdateGeneticRequestAsync(GeneticRequest geneticRequest)
|
|
{
|
|
await _geneticRepository.UpdateGeneticRequestAsync(geneticRequest);
|
|
}
|
|
|
|
public void DeleteGeneticRequestByIdForUser(User user, string id)
|
|
{
|
|
_geneticRepository.DeleteGeneticRequestByIdForUser(user, id);
|
|
}
|
|
|
|
public Task<List<GeneticRequest>> GetGeneticRequestsAsync(GeneticRequestStatus status)
|
|
{
|
|
return _geneticRepository.GetGeneticRequestsAsync(status);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Runs the genetic algorithm for a specific request
|
|
/// </summary>
|
|
/// <param name="request">The genetic request to process</param>
|
|
/// <param name="cancellationToken">Cancellation token to stop the algorithm</param>
|
|
/// <returns>The genetic algorithm result</returns>
|
|
public async Task<GeneticAlgorithmResult> RunGeneticAlgorithm(GeneticRequest request,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
try
|
|
{
|
|
_logger.LogInformation("Starting genetic algorithm for request {RequestId}", request.RequestId);
|
|
|
|
// Update status to running
|
|
request.Status = GeneticRequestStatus.Running;
|
|
await UpdateGeneticRequestAsync(request);
|
|
|
|
// Create or resume chromosome for trading bot configuration
|
|
TradingBotChromosome chromosome;
|
|
Population population;
|
|
|
|
if (!string.IsNullOrEmpty(request.BestChromosome) && request.CurrentGeneration > 0)
|
|
{
|
|
// Resume from previous state (best chromosome only)
|
|
chromosome = new TradingBotChromosome(request.EligibleIndicators, request.MaxTakeProfit);
|
|
var savedChromosome = JsonSerializer.Deserialize<double[]>(request.BestChromosome);
|
|
if (savedChromosome != null)
|
|
{
|
|
chromosome.ReplaceGenes(0, savedChromosome.Select(g => new Gene(g)).ToArray());
|
|
}
|
|
|
|
population = new Population(request.PopulationSize, request.PopulationSize, chromosome);
|
|
_logger.LogInformation(
|
|
"Resuming genetic algorithm for request {RequestId} from generation {Generation} with best chromosome",
|
|
request.RequestId, request.CurrentGeneration);
|
|
}
|
|
else
|
|
{
|
|
// Start fresh
|
|
chromosome = new TradingBotChromosome(request.EligibleIndicators, request.MaxTakeProfit);
|
|
population = new Population(request.PopulationSize, request.PopulationSize, chromosome);
|
|
_logger.LogInformation("Starting fresh genetic algorithm for request {RequestId}", request.RequestId);
|
|
}
|
|
|
|
// Load candles once at the beginning to avoid repeated database queries
|
|
// This significantly reduces database connections during genetic algorithm execution
|
|
_logger.LogInformation(
|
|
"Loading candles for genetic algorithm {RequestId}: {Ticker} on {Timeframe} from {StartDate} to {EndDate}",
|
|
request.RequestId, request.Ticker, request.Timeframe, request.StartDate, request.EndDate);
|
|
|
|
HashSet<Candle> candles;
|
|
try
|
|
{
|
|
candles = await ServiceScopeHelpers.WithScopedService<ICandleRepository, HashSet<Candle>>(
|
|
_serviceScopeFactory,
|
|
async candleRepository => await candleRepository.GetCandles(
|
|
TradingExchanges.Evm, // Default exchange for genetic algorithms
|
|
request.Ticker,
|
|
request.Timeframe,
|
|
request.StartDate,
|
|
request.EndDate
|
|
)
|
|
);
|
|
|
|
if (candles == null || candles.Count == 0)
|
|
{
|
|
throw new InvalidOperationException(
|
|
$"No candles found for {request.Ticker} on {request.Timeframe} from {request.StartDate} to {request.EndDate}");
|
|
}
|
|
|
|
_logger.LogInformation("Loaded {CandleCount} candles for genetic algorithm {RequestId}",
|
|
candles.Count, request.RequestId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to load candles for genetic algorithm {RequestId}", request.RequestId);
|
|
throw;
|
|
}
|
|
|
|
// Create fitness function with pre-loaded candles to avoid database queries during evaluation
|
|
var fitness = new TradingBotFitness(_serviceScopeFactory, request, candles, _logger);
|
|
|
|
// Create genetic algorithm with better configuration
|
|
// Limit parallelism to prevent database connection pool exhaustion
|
|
// Each fitness evaluation creates a database connection, so we need to limit
|
|
// the number of parallel evaluations to stay within connection pool limits
|
|
// Default PostgreSQL pool is 20 connections, so we limit to 4 threads per genetic job
|
|
// This leaves room for other operations and multiple concurrent genetic jobs
|
|
var maxParallelThreads = Math.Min(4, Environment.ProcessorCount);
|
|
var ga = new GeneticAlgorithm(
|
|
population,
|
|
fitness,
|
|
GetSelection(request.SelectionMethod),
|
|
GetCrossover(request.CrossoverMethod),
|
|
GetMutation(request.MutationMethod))
|
|
{
|
|
Termination = new OrTermination(
|
|
new GenerationNumberTermination(request.Generations),
|
|
new FitnessStagnationTermination(15)
|
|
),
|
|
MutationProbability = (float)request.MutationRate,
|
|
CrossoverProbability = 0.75f, // Fixed crossover rate as in frontend
|
|
TaskExecutor = new ParallelTaskExecutor
|
|
{
|
|
MinThreads = 2,
|
|
MaxThreads = maxParallelThreads
|
|
}
|
|
};
|
|
|
|
// Set the genetic algorithm reference in the fitness function
|
|
fitness.SetGeneticAlgorithm(ga);
|
|
|
|
// Custom termination condition that checks for cancellation
|
|
var originalTermination = ga.Termination;
|
|
ga.Termination = new GenerationNumberTermination(request.Generations);
|
|
|
|
// Add cancellation check in the generation event
|
|
|
|
// Run the genetic algorithm with periodic checks for cancellation
|
|
var generationCount = 0;
|
|
ga.GenerationRan += async (sender, e) =>
|
|
{
|
|
try
|
|
{
|
|
generationCount = ga.GenerationsNumber;
|
|
|
|
// Update progress every generation
|
|
var bestFitness = ga.BestChromosome?.Fitness ?? 0;
|
|
var bestChromosomeJson = (string?)null;
|
|
var bestIndividual = (string?)null;
|
|
|
|
if (ga.BestChromosome is TradingBotChromosome bestChromosome)
|
|
{
|
|
var genes = bestChromosome.GetGenes();
|
|
var geneValues = genes.Select(g =>
|
|
{
|
|
if (g.Value is double doubleValue) return doubleValue;
|
|
if (g.Value is int intValue) return (double)intValue;
|
|
return Convert.ToDouble(g.Value.ToString());
|
|
}).ToArray();
|
|
bestChromosomeJson = JsonSerializer.Serialize(geneValues);
|
|
bestIndividual = bestChromosome.ToString();
|
|
}
|
|
|
|
// Update ProgressInfo with current generation information
|
|
var progressInfo = JsonSerializer.Serialize(new
|
|
{
|
|
generation = generationCount,
|
|
best_fitness = bestFitness,
|
|
population_size = request.PopulationSize,
|
|
generations = request.Generations,
|
|
updated_at = DateTime.UtcNow
|
|
});
|
|
|
|
// Update the domain object for local use
|
|
request.CurrentGeneration = generationCount;
|
|
request.BestFitnessSoFar = bestFitness;
|
|
request.BestChromosome = bestChromosomeJson;
|
|
request.BestIndividual = bestIndividual;
|
|
request.ProgressInfo = progressInfo;
|
|
|
|
// Update the database with current generation progress using a new scope
|
|
// This prevents DbContext concurrency issues when running in parallel
|
|
await ServiceScopeHelpers.WithScopedService<IGeneticService>(
|
|
_serviceScopeFactory,
|
|
async geneticService =>
|
|
{
|
|
// Reload the request from the database in the new scope
|
|
// Use the user from the original request to get the request by ID
|
|
var dbRequest =
|
|
geneticService.GetGeneticRequestByIdForUser(request.User, request.RequestId);
|
|
|
|
if (dbRequest != null)
|
|
{
|
|
// Update the loaded request with current generation data
|
|
dbRequest.CurrentGeneration = generationCount;
|
|
dbRequest.BestFitnessSoFar = bestFitness;
|
|
dbRequest.BestChromosome = bestChromosomeJson;
|
|
dbRequest.BestIndividual = bestIndividual;
|
|
dbRequest.ProgressInfo = progressInfo;
|
|
|
|
// Save the update
|
|
await geneticService.UpdateGeneticRequestAsync(dbRequest);
|
|
}
|
|
});
|
|
|
|
_logger.LogDebug(
|
|
"Updated genetic request {RequestId} at generation {Generation} with fitness {Fitness}",
|
|
request.RequestId, generationCount, bestFitness);
|
|
|
|
// Check for cancellation
|
|
if (cancellationToken.IsCancellationRequested)
|
|
{
|
|
ga.Stop();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error updating genetic request {RequestId} at generation {Generation}",
|
|
request.RequestId, generationCount);
|
|
// Don't throw - continue with next generation
|
|
}
|
|
};
|
|
|
|
// Run the genetic algorithm
|
|
ga.Start();
|
|
|
|
// Check if the algorithm was cancelled
|
|
if (cancellationToken.IsCancellationRequested)
|
|
{
|
|
_logger.LogInformation("Genetic algorithm cancelled for request {RequestId}", request.RequestId);
|
|
|
|
// Update request status to pending so it can be resumed
|
|
request.Status = GeneticRequestStatus.Pending;
|
|
await UpdateGeneticRequestAsync(request);
|
|
|
|
return new GeneticAlgorithmResult
|
|
{
|
|
BestFitness = request.BestFitnessSoFar ?? 0,
|
|
BestIndividual = request.BestIndividual ?? "unknown",
|
|
ProgressInfo = request.ProgressInfo,
|
|
CompletedAt = DateTime.UtcNow
|
|
};
|
|
}
|
|
|
|
// Get the best chromosome
|
|
var bestChromosome = ga.BestChromosome as TradingBotChromosome;
|
|
var bestFitness = ga.BestChromosome?.Fitness ?? 0;
|
|
|
|
_logger.LogInformation("Genetic algorithm completed for request {RequestId}. Best fitness: {Fitness}",
|
|
request.RequestId, bestFitness);
|
|
|
|
// Update request with final results
|
|
request.Status = GeneticRequestStatus.Completed;
|
|
request.CompletedAt = DateTime.UtcNow;
|
|
request.BestFitness = bestFitness;
|
|
request.BestIndividual = bestChromosome?.ToString() ?? "unknown";
|
|
request.CurrentGeneration = ga.GenerationsNumber;
|
|
request.BestFitnessSoFar = bestFitness;
|
|
|
|
// Update BestChromosome if not already set
|
|
if (bestChromosome != null && string.IsNullOrEmpty(request.BestChromosome))
|
|
{
|
|
var genes = bestChromosome.GetGenes();
|
|
var geneValues = genes.Select(g =>
|
|
{
|
|
if (g.Value is double doubleValue) return doubleValue;
|
|
if (g.Value is int intValue) return (double)intValue;
|
|
return Convert.ToDouble(g.Value.ToString());
|
|
}).ToArray();
|
|
request.BestChromosome = JsonSerializer.Serialize(geneValues);
|
|
}
|
|
|
|
request.ProgressInfo = JsonSerializer.Serialize(new
|
|
{
|
|
generation = ga.GenerationsNumber,
|
|
best_fitness = bestFitness,
|
|
population_size = request.PopulationSize,
|
|
generations = request.Generations,
|
|
completed_at = DateTime.UtcNow
|
|
});
|
|
|
|
await UpdateGeneticRequestAsync(request);
|
|
|
|
_logger.LogInformation(
|
|
"Final update completed for genetic request {RequestId}. Generation: {Generation}, Best Fitness: {Fitness}",
|
|
request.RequestId, ga.GenerationsNumber, bestFitness);
|
|
|
|
// Send notification about the completed genetic algorithm
|
|
try
|
|
{
|
|
await _messengerService.SendGeneticAlgorithmNotification(request, bestFitness, bestChromosome);
|
|
}
|
|
catch (Exception notificationEx)
|
|
{
|
|
_logger.LogWarning(notificationEx,
|
|
"Failed to send genetic algorithm notification for request {RequestId}", request.RequestId);
|
|
}
|
|
|
|
return new GeneticAlgorithmResult
|
|
{
|
|
BestFitness = bestFitness,
|
|
BestIndividual = bestChromosome?.ToString() ?? "unknown",
|
|
ProgressInfo = request.ProgressInfo,
|
|
CompletedAt = DateTime.UtcNow
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error running genetic algorithm for request {RequestId}", request.RequestId);
|
|
|
|
// Update request with error
|
|
request.Status = GeneticRequestStatus.Failed;
|
|
request.ErrorMessage = ex.Message;
|
|
request.CompletedAt = DateTime.UtcNow;
|
|
await UpdateGeneticRequestAsync(request);
|
|
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private ISelection GetSelection(GeneticSelectionMethod selectionMethod)
|
|
{
|
|
return selectionMethod switch
|
|
{
|
|
GeneticSelectionMethod.Elite => new EliteSelection(),
|
|
GeneticSelectionMethod.Roulette => new RouletteWheelSelection(),
|
|
GeneticSelectionMethod.StochasticUniversalSampling => new StochasticUniversalSamplingSelection(),
|
|
GeneticSelectionMethod.Tournament => new TournamentSelection(),
|
|
GeneticSelectionMethod.Truncation => new TruncationSelection(),
|
|
_ => new TournamentSelection()
|
|
};
|
|
}
|
|
|
|
private ICrossover GetCrossover(GeneticCrossoverMethod crossoverMethod)
|
|
{
|
|
return crossoverMethod switch
|
|
{
|
|
GeneticCrossoverMethod.AlternatingPosition => new AlternatingPositionCrossover(),
|
|
GeneticCrossoverMethod.CutAndSplice => new CutAndSpliceCrossover(),
|
|
GeneticCrossoverMethod.Cycle => new CycleCrossover(),
|
|
GeneticCrossoverMethod.OnePoint => new OnePointCrossover(),
|
|
GeneticCrossoverMethod.OrderBased => new OrderBasedCrossover(),
|
|
GeneticCrossoverMethod.Ordered => new OrderedCrossover(),
|
|
GeneticCrossoverMethod.PartiallyMapped => new PartiallyMappedCrossover(),
|
|
GeneticCrossoverMethod.PositionBased => new PositionBasedCrossover(),
|
|
GeneticCrossoverMethod.ThreeParent => new ThreeParentCrossover(),
|
|
GeneticCrossoverMethod.TwoPoint => new TwoPointCrossover(),
|
|
GeneticCrossoverMethod.Uniform => new UniformCrossover(),
|
|
GeneticCrossoverMethod.VotingRecombination => new VotingRecombinationCrossover(),
|
|
_ => new UniformCrossover()
|
|
};
|
|
}
|
|
|
|
private IMutation GetMutation(GeneticMutationMethod mutationMethod)
|
|
{
|
|
return mutationMethod switch
|
|
{
|
|
GeneticMutationMethod.Displacement => new DisplacementMutation(),
|
|
GeneticMutationMethod.FlipBit => new FlipBitMutation(),
|
|
GeneticMutationMethod.Insertion => new InsertionMutation(),
|
|
GeneticMutationMethod.PartialShuffle => new PartialShuffleMutation(),
|
|
GeneticMutationMethod.ReverseSequence => new ReverseSequenceMutation(),
|
|
GeneticMutationMethod.Twors => new TworsMutation(),
|
|
GeneticMutationMethod.Uniform => new UniformMutation(true),
|
|
_ => new UniformMutation(true)
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chromosome representing a trading bot configuration with predefined parameter ranges
|
|
/// </summary>
|
|
public class TradingBotChromosome : ChromosomeBase
|
|
{
|
|
private readonly List<IndicatorType> _eligibleIndicators;
|
|
private readonly double _maxTakeProfit;
|
|
private readonly Random _random = new Random();
|
|
private int[] _indicatorSelectionPattern;
|
|
|
|
// Gene structure:
|
|
// 0-3: Trading parameters (takeProfit, stopLoss, cooldownPeriod, maxLossStreak)
|
|
// 4: Loopback period
|
|
// 5-4+N: Indicator selection (N = number of eligible indicators)
|
|
// 5+N+: Indicator parameters (period, fastPeriods, etc.)
|
|
|
|
public TradingBotChromosome(List<IndicatorType> eligibleIndicators, double maxTakeProfit)
|
|
: base(4 + 1 + eligibleIndicators.Count +
|
|
eligibleIndicators.Count * 8) // Trading params + loopback + indicator selection + indicator params
|
|
{
|
|
_eligibleIndicators = eligibleIndicators;
|
|
_maxTakeProfit = maxTakeProfit;
|
|
|
|
// Initialize genes with proper constraint handling
|
|
InitializeGenesWithConstraints();
|
|
}
|
|
|
|
public override Gene GenerateGene(int geneIndex)
|
|
{
|
|
if (geneIndex < 4)
|
|
{
|
|
// Trading parameters
|
|
return geneIndex switch
|
|
{
|
|
0 => new Gene(GetRandomInRange((0.9, _maxTakeProfit))), // Take profit (0.9% to max TP)
|
|
1 => new Gene(GetRandomInRange((0.2, 50.0))), // Stop loss (will be constrained in GetTradingBotConfig)
|
|
2 => new Gene(GetRandomIntInRange(GeneticService.ParameterRanges["cooldownPeriod"])), // Cooldown period
|
|
3 => new Gene(GetRandomIntInRange(GeneticService.ParameterRanges["maxLossStreak"])), // Max loss streak
|
|
_ => new Gene(0)
|
|
};
|
|
}
|
|
else if (geneIndex == 4)
|
|
{
|
|
// LoopbackPeriod gene (always between 5 and 20)
|
|
return new Gene(GetRandomIntInRange((5, 20)));
|
|
}
|
|
else if (geneIndex < 5 + _eligibleIndicators.Count)
|
|
{
|
|
// Indicator selection (0 = not selected, 1 = selected)
|
|
// Generate a random combination of up to 4 indicators
|
|
if (_indicatorSelectionPattern == null)
|
|
{
|
|
GenerateIndicatorSelectionPattern();
|
|
}
|
|
|
|
return new Gene(_indicatorSelectionPattern[geneIndex - 5]);
|
|
}
|
|
else
|
|
{
|
|
// Indicator parameters
|
|
var indicatorIndex = (geneIndex - (5 + _eligibleIndicators.Count)) / 8;
|
|
var paramIndex = (geneIndex - (5 + _eligibleIndicators.Count)) % 8;
|
|
|
|
if (indicatorIndex < _eligibleIndicators.Count)
|
|
{
|
|
var indicator = _eligibleIndicators[indicatorIndex];
|
|
var paramName = GetParameterName(paramIndex);
|
|
|
|
if (paramName != null && GeneticService.IndicatorParamMapping.ContainsKey(indicator))
|
|
{
|
|
var requiredParams = GeneticService.IndicatorParamMapping[indicator];
|
|
if (requiredParams.Contains(paramName))
|
|
{
|
|
// Use indicator-specific ranges only
|
|
if (GeneticService.IndicatorParameterRanges.ContainsKey(indicator) &&
|
|
GeneticService.IndicatorParameterRanges[indicator].ContainsKey(paramName))
|
|
{
|
|
var indicatorRange = GeneticService.IndicatorParameterRanges[indicator][paramName];
|
|
|
|
// 70% chance to use default value, 30% chance to use random value within indicator-specific range
|
|
if (_random.NextDouble() < 0.7)
|
|
{
|
|
var defaultValues = GeneticService.DefaultIndicatorValues[indicator];
|
|
return new Gene(defaultValues[paramName]);
|
|
}
|
|
else
|
|
{
|
|
return new Gene(GetRandomInRange(indicatorRange));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If no indicator-specific range is found, use default value only
|
|
var defaultValues = GeneticService.DefaultIndicatorValues[indicator];
|
|
return new Gene(defaultValues[paramName]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return new Gene(0);
|
|
}
|
|
}
|
|
|
|
public override IChromosome CreateNew()
|
|
{
|
|
return new TradingBotChromosome(_eligibleIndicators, _maxTakeProfit);
|
|
}
|
|
|
|
public override IChromosome Clone()
|
|
{
|
|
var clone = new TradingBotChromosome(_eligibleIndicators, _maxTakeProfit);
|
|
clone.ReplaceGenes(0, GetGenes());
|
|
// Copy the selection pattern to maintain consistency
|
|
if (_indicatorSelectionPattern != null)
|
|
{
|
|
clone._indicatorSelectionPattern = (int[])_indicatorSelectionPattern.Clone();
|
|
}
|
|
|
|
return clone;
|
|
}
|
|
|
|
public List<LightIndicator> GetSelectedIndicators()
|
|
{
|
|
var selected = new List<LightIndicator>();
|
|
var genes = GetGenes();
|
|
|
|
// Check all indicator selection slots (genes 5 to 5+N-1 where N is number of eligible indicators)
|
|
for (int i = 0; i < _eligibleIndicators.Count; i++)
|
|
{
|
|
if (genes[5 + i].Value.ToString() == "1")
|
|
{
|
|
var indicator = new LightIndicator(_eligibleIndicators[i].ToString(), _eligibleIndicators[i])
|
|
{
|
|
Type = _eligibleIndicators[i]
|
|
};
|
|
|
|
// Add parameters for this indicator
|
|
var baseIndex = 5 + _eligibleIndicators.Count + i * 8;
|
|
var paramName = GetParameterName(0); // period
|
|
if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
|
|
{
|
|
indicator.Period = Convert.ToInt32(genes[baseIndex].Value);
|
|
}
|
|
|
|
paramName = GetParameterName(1); // fastPeriods
|
|
if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
|
|
{
|
|
indicator.FastPeriods = Convert.ToInt32(genes[baseIndex + 1].Value);
|
|
}
|
|
|
|
paramName = GetParameterName(2); // slowPeriods
|
|
if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
|
|
{
|
|
indicator.SlowPeriods = Convert.ToInt32(genes[baseIndex + 2].Value);
|
|
}
|
|
|
|
paramName = GetParameterName(3); // signalPeriods
|
|
if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
|
|
{
|
|
indicator.SignalPeriods = Convert.ToInt32(genes[baseIndex + 3].Value);
|
|
}
|
|
|
|
paramName = GetParameterName(4); // multiplier
|
|
if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
|
|
{
|
|
indicator.Multiplier = Convert.ToDouble(genes[baseIndex + 4].Value);
|
|
}
|
|
|
|
paramName = GetParameterName(5); // stochPeriods
|
|
if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
|
|
{
|
|
indicator.StochPeriods = Convert.ToInt32(genes[baseIndex + 5].Value);
|
|
}
|
|
|
|
paramName = GetParameterName(6); // smoothPeriods
|
|
if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
|
|
{
|
|
indicator.SmoothPeriods = Convert.ToInt32(genes[baseIndex + 6].Value);
|
|
}
|
|
|
|
paramName = GetParameterName(7); // cyclePeriods
|
|
if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
|
|
{
|
|
indicator.CyclePeriods = Convert.ToInt32(genes[baseIndex + 7].Value);
|
|
}
|
|
|
|
selected.Add(indicator);
|
|
}
|
|
}
|
|
|
|
return selected;
|
|
}
|
|
|
|
public TradingBotConfig GetTradingBotConfig(GeneticRequest request)
|
|
{
|
|
var genes = GetGenes();
|
|
var selectedIndicators = GetSelectedIndicators();
|
|
|
|
// The selection pattern ensures at least one indicator is always selected
|
|
// No need for fallback logic
|
|
|
|
// Get take profit from chromosome (gene 0)
|
|
var takeProfit = Convert.ToDouble(genes[0].Value);
|
|
|
|
// Get stop loss from chromosome (gene 1)
|
|
var stopLoss = Convert.ToDouble(genes[1].Value);
|
|
|
|
// Enforce proper risk-reward constraints
|
|
var minStopLoss = 0.2; // Minimum 0.2% to cover fees
|
|
var maxStopLoss = takeProfit / 1.1; // Ensure risk-reward ratio is at least 1.1:1
|
|
|
|
// Generate a random stop loss between min and max
|
|
var randomStopLoss = GetRandomInRange((minStopLoss, maxStopLoss));
|
|
|
|
// Use the random value instead of clamping the original
|
|
stopLoss = randomStopLoss;
|
|
|
|
// Log the generated values (for debugging)
|
|
Console.WriteLine($"Generated: TP={takeProfit:F2}%, SL={stopLoss:F2}% (RR={takeProfit / stopLoss:F2}:1)");
|
|
|
|
// Get loopback period from gene 4
|
|
var loopbackPeriod = Convert.ToInt32(genes[4].Value);
|
|
|
|
// Build scenario using selected indicators
|
|
var scenario = new LightScenario($"Genetic_{request.RequestId}_Scenario", loopbackPeriod)
|
|
{
|
|
Indicators = selectedIndicators
|
|
};
|
|
|
|
var mm = new MoneyManagement
|
|
{
|
|
Name = $"Genetic_{request.RequestId}_MM",
|
|
Timeframe = request.Timeframe,
|
|
StopLoss = Convert.ToDecimal(stopLoss),
|
|
TakeProfit = Convert.ToDecimal(takeProfit),
|
|
Leverage = 1.0m
|
|
};
|
|
mm.FormatPercentage();
|
|
|
|
return new TradingBotConfig
|
|
{
|
|
Name = $"Genetic_{request.RequestId}",
|
|
AccountName = request.User.Accounts.FirstOrDefault().Name,
|
|
Ticker = request.Ticker,
|
|
Timeframe = request.Timeframe,
|
|
BotTradingBalance = request.Balance,
|
|
IsForBacktest = true,
|
|
IsForWatchingOnly = false,
|
|
CooldownPeriod = Convert.ToInt32(genes[2].Value),
|
|
MaxLossStreak = Convert.ToInt32(genes[3].Value),
|
|
FlipPosition = false,
|
|
FlipOnlyWhenInProfit = true,
|
|
CloseEarlyWhenProfitable = true,
|
|
MaxPositionTimeHours = 0, // Always 0 to prevent early position cutting
|
|
UseSynthApi = false,
|
|
UseForPositionSizing = false,
|
|
UseForSignalFiltering = false,
|
|
UseForDynamicStopLoss = false,
|
|
Scenario = scenario,
|
|
MoneyManagement = mm,
|
|
RiskManagement = new RiskManagement
|
|
{
|
|
RiskTolerance = RiskToleranceLevel.Moderate
|
|
}
|
|
};
|
|
}
|
|
|
|
private double GetRandomInRange((double min, double max) range)
|
|
{
|
|
return _random.NextDouble() * (range.max - range.min) + range.min;
|
|
}
|
|
|
|
private int GetRandomIntInRange((double min, double max) range)
|
|
{
|
|
return _random.Next((int)range.min, (int)range.max + 1);
|
|
}
|
|
|
|
private string GetParameterName(int index)
|
|
{
|
|
return index switch
|
|
{
|
|
0 => "period",
|
|
1 => "fastPeriods",
|
|
2 => "slowPeriods",
|
|
3 => "signalPeriods",
|
|
4 => "multiplier",
|
|
5 => "stochPeriods",
|
|
6 => "smoothPeriods",
|
|
7 => "cyclePeriods",
|
|
_ => null
|
|
};
|
|
}
|
|
|
|
private bool HasParameter(IndicatorType indicator, string paramName)
|
|
{
|
|
return GeneticService.IndicatorParamMapping.ContainsKey(indicator) &&
|
|
GeneticService.IndicatorParamMapping[indicator].Contains(paramName);
|
|
}
|
|
|
|
private void GenerateIndicatorSelectionPattern()
|
|
{
|
|
// Generate a random combination of up to 4 indicators
|
|
var selectedCount = _random.Next(1, Math.Min(5, _eligibleIndicators.Count + 1)); // 1 to 4 indicators
|
|
var selectedIndices = new HashSet<int>();
|
|
|
|
// Randomly select indices
|
|
while (selectedIndices.Count < selectedCount)
|
|
{
|
|
selectedIndices.Add(_random.Next(_eligibleIndicators.Count));
|
|
}
|
|
|
|
// Create the selection pattern
|
|
_indicatorSelectionPattern = new int[_eligibleIndicators.Count];
|
|
for (int i = 0; i < _eligibleIndicators.Count; i++)
|
|
{
|
|
_indicatorSelectionPattern[i] = selectedIndices.Contains(i) ? 1 : 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes genes with proper constraint handling for take profit and stop loss
|
|
/// </summary>
|
|
private void InitializeGenesWithConstraints()
|
|
{
|
|
// Generate take profit first (gene 0)
|
|
var takeProfit = GetRandomInRange((0.9, _maxTakeProfit));
|
|
ReplaceGene(0, new Gene(takeProfit));
|
|
|
|
// Generate stop loss with proper constraints (gene 1)
|
|
var minStopLoss = 0.2; // Minimum 0.2% to cover fees
|
|
var maxStopLoss = takeProfit / 1.1; // Ensure risk-reward ratio is at least 1.1:1
|
|
var stopLoss = GetRandomInRange((minStopLoss, maxStopLoss));
|
|
ReplaceGene(1, new Gene(stopLoss));
|
|
|
|
// Log the initial values (for debugging)
|
|
Console.WriteLine($"Initialized: TP={takeProfit:F2}%, SL={stopLoss:F2}% (RR={takeProfit / stopLoss:F2}:1)");
|
|
|
|
// Initialize remaining genes normally
|
|
for (int i = 2; i < Length; i++)
|
|
{
|
|
ReplaceGene(i, GenerateGene(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multi-objective fitness function for trading bot optimization
|
|
/// </summary>
|
|
public class TradingBotFitness : IFitness
|
|
{
|
|
private readonly IServiceScopeFactory _serviceScopeFactory;
|
|
private readonly GeneticRequest _request;
|
|
private GeneticAlgorithm _geneticAlgorithm;
|
|
private readonly ILogger<GeneticService> _logger;
|
|
private readonly HashSet<Candle> _candles;
|
|
private static readonly SemaphoreSlim _dbSemaphore = new SemaphoreSlim(4, 4); // Limit concurrent DB operations
|
|
|
|
public TradingBotFitness(
|
|
IServiceScopeFactory serviceScopeFactory,
|
|
GeneticRequest request,
|
|
HashSet<Candle> candles,
|
|
ILogger<GeneticService> logger)
|
|
{
|
|
_serviceScopeFactory = serviceScopeFactory;
|
|
_request = request;
|
|
_candles = candles;
|
|
_logger = logger;
|
|
}
|
|
|
|
public void SetGeneticAlgorithm(GeneticAlgorithm geneticAlgorithm)
|
|
{
|
|
_geneticAlgorithm = geneticAlgorithm;
|
|
}
|
|
|
|
public double Evaluate(IChromosome chromosome)
|
|
{
|
|
try
|
|
{
|
|
var tradingBotChromosome = chromosome as TradingBotChromosome;
|
|
if (tradingBotChromosome == null)
|
|
return 0;
|
|
|
|
var config = tradingBotChromosome.GetTradingBotConfig(_request);
|
|
|
|
// Run backtest synchronously using BacktestExecutor (no job creation, no DB writes)
|
|
// Use semaphore to limit concurrent database operations (for indicator calculations)
|
|
// This prevents connection pool exhaustion when running large populations
|
|
_dbSemaphore.Wait();
|
|
LightBacktest lightBacktest;
|
|
try
|
|
{
|
|
lightBacktest = ServiceScopeHelpers.WithScopedService<BacktestExecutor, LightBacktest>(
|
|
_serviceScopeFactory,
|
|
async executor => await executor.ExecuteAsync(
|
|
config,
|
|
_candles,
|
|
_request.User,
|
|
save: false, // Don't save backtest results for genetic algorithm
|
|
withCandles: false,
|
|
requestId: _request.RequestId,
|
|
bundleRequestId: null, // Genetic algorithm doesn't use bundle requests
|
|
metadata: new GeneticBacktestMetadata(_geneticAlgorithm?.GenerationsNumber ?? 0,
|
|
_request.RequestId),
|
|
progressCallback: null,
|
|
cancellationToken: default
|
|
)
|
|
).GetAwaiter().GetResult();
|
|
}
|
|
finally
|
|
{
|
|
_dbSemaphore.Release();
|
|
}
|
|
|
|
// Calculate multi-objective fitness based on backtest results
|
|
var fitness = CalculateFitness(lightBacktest, config);
|
|
|
|
return fitness;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning("Fitness evaluation failed for chromosome: {Message}", ex.Message);
|
|
// Return low fitness for failed backtests
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private double CalculateFitness(LightBacktest lightBacktest, TradingBotConfig config)
|
|
{
|
|
if (lightBacktest == null)
|
|
return 0.1;
|
|
|
|
// Calculate base fitness from backtest score
|
|
var baseFitness = lightBacktest.Score;
|
|
|
|
// Return base fitness (no penalty for now)
|
|
return baseFitness;
|
|
}
|
|
} |