public SVDRecommender(DataModel dataModel, Factorizer factorizer, CandidateItemsStrategy candidateItemsStrategy, PersistenceStrategy persistenceStrategy)
: base(dataModel, candidateItemsStrategy)
{
Action refreshRunnable = null;
this.factorizer = factorizer;
this.persistenceStrategy = persistenceStrategy;
try
{
this.factorization = persistenceStrategy.load();
}
catch (IOException exception)
{
throw new TasteException("Error loading factorization", exception);
}
if (this.factorization == null)
{
this.train();
}
if (refreshRunnable == null)
{
refreshRunnable = () => this.train();
}
this.refreshHelper = new RefreshHelper(refreshRunnable);
this.refreshHelper.addDependency(this.getDataModel());
this.refreshHelper.addDependency(factorizer);
this.refreshHelper.addDependency(candidateItemsStrategy);
}
public static void Run(PersistenceStrategy strategy, IDependencyInjector container)
{
container.BindToConstant <ILogger>(new DefaultLogger());
container.Get <ILogger>().Trace("Bootstrapper", "starting the bootstrapper.");
SetupBus(container);
SetupDomainCommandHandlers(container);
switch (strategy)
{
case PersistenceStrategy.InMemory:
container.Get <ILogger>().Trace("Bootstrapper", "bootstrapping In-Memory strategy");
SetupInMemoryRepo(container);
break;
case PersistenceStrategy.InMemoryEventSourcing:
container.Get <ILogger>().Trace("Bootstrapper", "bootstrapping In-Memory ES strategy");
SetupInMemoryEsRepo(container);
break;
default:
container.Get <ILogger>().Trace("Bootstrapper", "bootstrapping RavenDb strategy");
SetupRavenDbRepo(container);
break;
}
container.Get <ILogger>().Trace("Bootstrapper", "done.");
}
public async Task <bool> TrySetStringAsync(string key, string value)
{
try
{
await PersistenceStrategy.SaveAsync(key, value);
return(true);
}
catch
{
return(false);
}
}
public async Task <bool> TrySetAsync <T>(string key, T value)
{
try
{
var result = SerializationStrategy.Serialize(value);
await PersistenceStrategy.SaveAsync(key, result);
return(true);
}
catch
{
return(false);
}
}
private void CreateDataPoint(Reading newReading, PersistenceStrategy persistStrategy)
{
DateTime originalSlotExpiryTimestamp = this.slotExpiryTimestamp;
// Push as many missing NaN data points as necessary to the queue
PushMissingDataPoints(newReading.Timestamp);
/*
* Calculate the percentage of readings that are missing versus the x
* factor (minimum % of readings required for the current slot
* to produce a valid value.) If the percentage is the same or higher
* than the x factor then push the accumulated data point into the queue. If
* sufficient readings have not accumulated during this slot, then push a
* NaN data point into the queue.
*/
if (CalcAccumulatedReadingsRatioAsPercentage() >= this.template.XFactor)
{
/*
* Sufficient readings have been received so push the consolidated data point. The
* data point inherits the timestamp of the final reading
*/
this.dataPointCircularQueue.Add(CreateConsolidationFunction().CreateAccumulatedDataPoint(newReading));
}
else
{
/*
* Not enough readings have been received for the current
* slot, push a NaN value into the queue
*/
this.dataPointCircularQueue.Add(DataPoint.CreateNaN(newReading.Timestamp));
}
ResetAccumulatedReadings();
if (originalSlotExpiryTimestamp == this.slotExpiryTimestamp)
{
CalcNextSlotExpiryTime();
}
if (persistStrategy != PersistenceStrategy.DelayWrite)
{
// Save the changes that haven't been persisted to disk
this.dataPointCircularQueue.PersistChanges();
}
}
public static async Task <int> Execute(
IBlockchainStoreRepositoryFactory repositoryFactory,
BlockchainSourceConfiguration configuration,
FilterContainer filterContainer = null,
bool useGeth = false)
{
IWeb3Wrapper web3 = new Web3Wrapper(
useGeth
? new Web3Geth(configuration.BlockchainUrl)
: new Web3.Web3(configuration.BlockchainUrl));
using (_strategy = new PersistenceStrategy(
repositoryFactory, filterContainer, minimumBlockNumber: configuration.MinimumBlockNumber ?? 0))
{
var blockProcessor = new BlockProcessorFactory()
.Create(
web3,
_strategy,
configuration.PostVm,
configuration.ProcessBlockTransactionsInParallel);
var blockchainProcessor = new BlockchainProcessor(_strategy, blockProcessor);
//this should not really be necessary
//but without it, when the process is killed early, some csv records where not being flushed
AppDomain.CurrentDomain.ProcessExit += (s, e) =>
{
_strategy?.Dispose();
};
var stopWatch = Stopwatch.StartNew();
var result = await blockchainProcessor.ExecuteAsync(configuration.FromBlock, configuration.ToBlock)
.ConfigureAwait(false);
System.Console.WriteLine("Duration: " + stopWatch.Elapsed);
Debug.WriteLine($"Finished With Success: {result}");
System.Console.WriteLine("Finished. Success:" + result);
System.Console.ReadLine();
return(result ? 0 : 1);
}
}
public async Task <TryResult <string> > TryGetStringAsync(string key)
{
var keys = await PersistenceStrategy.GetKeysAsync();
if (!(keys).Contains(key))
{
return(new TryResult <string>());
}
try
{
var value = await PersistenceStrategy.LoadAsync(key) as string;
return(new TryResult <string> {
Success = true, Value = value
});
}
catch
{
return(new TryResult <string>());
}
}
public async Task <TryResult <T> > TryGetAsync <T>(string key)
{
var keys = await PersistenceStrategy.GetKeysAsync();
if (!(keys).Contains(key))
{
return(new TryResult <T>());
}
try
{
var result = await PersistenceStrategy.LoadAsync(key);
var value = SerializationStrategy.Deserialize <T>(result);
return(new TryResult <T> {
Success = true, Value = value
});
}
catch
{
return(new TryResult <T>());
}
}
public Program(PersistenceStrategy strategy)
{
_strategy = strategy;
_container = new SimpleDependencyInjector();
Boostrapper.Run(strategy, _container);
}
public async Task ClearAsync() => await PersistenceStrategy.ClearAsync();
public async Task <string[]> GetKeysAsync() => await PersistenceStrategy.GetKeysAsync();
public static void AddStrategy(string key, PersistenceStrategy strategy)
{
strategies[key] = strategy;
}
public SVDRecommender(DataModel dataModel, Factorizer factorizer, PersistenceStrategy persistenceStrategy)
: this(dataModel, factorizer, AbstractRecommender.getDefaultCandidateItemsStrategy(), persistenceStrategy)
{
}
