public void BinaryRecommendationCustomSerializationRegressionTest()
{
// TODO: We need a static class which implements mapping chainings
Rand.Restart(12347);
var positiveOnlyMapping = new PositiveOnlyDataMapping();
var negativeDataGeneratorMapping = positiveOnlyMapping.WithGeneratedNegativeData(1.0);
using (Stream stream = new MemoryStream())
{
negativeDataGeneratorMapping.SaveForwardCompatibleAsBinary(stream);
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new WrappedBinaryReader(new BinaryReader(stream)))
{
var deserializedMapping =
new NegativeDataGeneratorMapping <PositiveOnlyDataset, Tuple <string, string>, string, string, FeatureProvider, Vector>(reader, positiveOnlyMapping);
var recommender = MatchboxRecommender.Create(deserializedMapping);
recommender.Train(this.positiveOnlyDataset, this.featureProvider); // must not throw
foreach (var instance in positiveOnlyMapping.GetInstances(this.positiveOnlyDataset))
{
var user = positiveOnlyMapping.GetUser(this.positiveOnlyDataset, instance);
var item = positiveOnlyMapping.GetItem(this.positiveOnlyDataset, instance);
Assert.Equal(1, recommender.Predict(user, item, this.featureProvider));
}
}
}
}
public void GaussianCustomSerializationTest()
{
using (var stream = new MemoryStream())
{
var writer = new WrappedBinaryWriter(new BinaryWriter(stream));
writer.Write(Gaussian.FromNatural(-13.89, 436.12));
writer.Write(Gaussian.PointMass(Math.PI));
writer.Write(Gaussian.Uniform());
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new WrappedBinaryReader(new BinaryReader(stream)))
{
Gaussian natural = reader.ReadGaussian();
Assert.Equal(-13.89, natural.MeanTimesPrecision);
Assert.Equal(436.12, natural.Precision);
Gaussian pointMass = reader.ReadGaussian();
Assert.True(pointMass.IsPointMass);
Assert.Equal(Math.PI, pointMass.GetMean());
Gaussian uniform = reader.ReadGaussian();
Assert.True(uniform.IsUniform());
}
}
}
public void GammaCustomSerializationTest()
{
using (var stream = new MemoryStream())
{
var writer = new WrappedBinaryWriter(new BinaryWriter(stream));
writer.Write(Gamma.FromShapeAndRate(1.0, 10.0));
writer.Write(Gamma.PointMass(Math.PI));
writer.Write(Gamma.Uniform());
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new WrappedBinaryReader(new BinaryReader(stream)))
{
Gamma shapeAndRate = reader.ReadGamma();
Assert.Equal(1.0, shapeAndRate.Shape);
Assert.Equal(10.0, shapeAndRate.Rate);
Gamma pointMass = reader.ReadGamma();
Assert.True(pointMass.IsPointMass);
Assert.Equal(Math.PI, pointMass.GetMean());
Gamma uniform = reader.ReadGamma();
Assert.True(uniform.IsUniform());
}
}
}
LoadBackwardCompatible <TInstanceSource, TInstance, TUser, TItem, TRating, TFeatureSource>(
Stream stream, IStarRatingRecommenderMapping <TInstanceSource, TInstance, TUser, TItem, TRating, TFeatureSource, Vector> mapping)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
using (var reader = new WrappedBinaryReader(new BinaryReader(stream, Encoding.UTF8, true)))
{
return(LoadBackwardCompatible(reader, mapping));
}
}
