public override void Deserialize(MLSerializer ser)
{
base.Deserialize(ser);
m_TFWeightingScheme = ser.ReadObject <ITFWeightingScheme>("TF_SCHEME");
m_IDFWeightingScheme = ser.ReadObject <IIDFWeightingScheme>("IDF_SCHEME");
}
public override void Serialize(MLSerializer ser)
{
base.Serialize(ser);
ser.Write("TF_SCHEME", m_TFWeightingScheme);
ser.Write("IDF_SCHEME", m_IDFWeightingScheme);
}
public override void Deserialize(MLSerializer ser)
{
base.Deserialize(ser);
m_UseSmoothing = ser.ReadBool("USE_SMOOTHING");
m_Alpha = ser.ReadDouble("ALPHA");
m_Weights = ser.ReadObject <double[][]>("WEIGHTS");
}
public override void Serialize(MLSerializer ser)
{
base.Serialize(ser);
ser.Write("USE_SMOOTHING", m_UseSmoothing);
ser.Write("ALPHA", m_Alpha);
ser.Write("WEIGHTS", m_Weights);
}
public virtual void Deserialize(MLSerializer ser)
{
var type = ser.ReadString("TYPE");
if (!string.Equals(type, GetType().FullName, StringComparison.InvariantCultureIgnoreCase))
{
throw new MLException(string.Format("Wrong type: expected {0}, actual {1}", type ?? "NULL", GetType().FullName));
}
}
/// <summary>
/// Obtiene una instancia de un servicio de escritura
/// </summary>
public IWriter GetInstance(MLSerializer.SerializerType intType, bool blnIncludeComments = false)
{ switch (intType)
{ case MLSerializer.SerializerType.XML:
return new XML.XMLWriter();
case MLSerializer.SerializerType.JSON:
return null; // new JSON.JsonParser();
default:
throw new ParserException("Tipo de intérprete desconocido");
}
}
public override void Serialize(MLSerializer ser)
{
base.Serialize(ser);
ser.Write("FEATURE_EXTRACTOR", m_FeatureExtractor);
ser.Write("PREPROCESSOR", m_Preprocessor);
ser.Write("VOCABULARY", m_Vocabulary);
ser.Write("PRIORS", m_PriorProbs);
ser.Write("CLASS_HIST", m_ClassHist);
ser.Write("DATA_DIM", m_DataDim);
ser.Write("DATA_COUNT", m_DataCount);
ser.Write("USE_PRIORS", m_UsePriors);
}
public override void Deserialize(MLSerializer ser)
{
base.Deserialize(ser);
m_FeatureExtractor = ser.ReadObject <ITextFeatureExtractor>("FEATURE_EXTRACTOR");
m_Preprocessor = ser.ReadObject <ITextPreprocessor>("PREPROCESSOR");
m_Vocabulary = ser.ReadStrings("VOCABULARY").ToList();
m_FeatureExtractor.Preprocessor = m_Preprocessor;
m_FeatureExtractor.Vocabulary = m_Vocabulary;
m_PriorProbs = ser.ReadDoubles("PRIORS").ToArray();
m_ClassHist = ser.ReadInts("CLASS_HIST").ToArray();
m_DataDim = ser.ReadInt("DATA_DIM");
m_DataCount = ser.ReadInt("DATA_COUNT");
m_UsePriors = ser.ReadBool("USE_PRIORS");
}
public void Deserialize(Stream stream)
{
using (var compr = new GZipStream(stream, CompressionMode.Decompress))
using (var ims = new MemoryStream())
{
compr.CopyTo(ims);
ims.Position = 0;
using (var reader = new StreamReader(ims))
{
var ser = new MLSerializer(reader);
Deserialize(ser);
}
}
}
public override void Deserialize(MLSerializer ser)
{
base.Deserialize(ser);
var classes = new List <Class>();
var names = ser.ReadStrings("CLASSES");
var idx = 0;
foreach (var name in names)
{
var cls = new Class(name, idx++);
classes.Add(cls);
}
Classes = classes.ToArray();
}
public void Serialize(Stream stream)
{
using (var ims = new MemoryStream())
using (var writer = new StreamWriter(ims)
{
AutoFlush = true
})
{
var ser = new MLSerializer(writer);
Serialize(ser);
ims.Position = 0;
using (var compr = new GZipStream(stream, CompressionMode.Compress))
ims.CopyTo(compr);
}
}
/// <summary>
/// Carga los datos de un archivo
/// </summary>
public Project Load(string strFileName)
{
Project objProject = new Project();
// Carga los datos
if (System.IO.File.Exists(strFileName))
{
MLFile objMLFile = new MLSerializer().Parse(MLSerializer.SerializerType.XML, strFileName);
foreach (MLNode objMLNode in objMLFile.Nodes)
{
if (objMLNode.Name == cnstStrTagRoot)
{
foreach (MLNode objMLChild in objMLNode.Nodes)
{
switch (objMLChild.Name)
{
case cnstStrTagContext:
objProject.Context = LoadContext(objMLChild);
break;
case cnstStrTagMessage:
objProject.Instructions.Add(LoadInstruction(objMLChild));
break;
case cnstStrTagAuthPlain:
objProject.Authenticator = LoadAuthenticationPlain(objMLChild);
break;
case cnstStrTagAuthOAuth:
objProject.Authenticator = LoadAuthenticationOAuth(objMLChild);
break;
}
}
}
}
}
// Devuelve el proyecto
return(objProject);
}
/// <summary>
/// Carga los datos de un archivo
/// </summary>
internal ProjectDocumentationModel Load(string strFileName)
{
ProjectDocumentationModel objProject = new ProjectDocumentationModel();
// Asigna el nombre de archivo
objProject.FileName = strFileName;
// Carga los datos
if (System.IO.File.Exists(strFileName))
{
MLFile objMLFile = new MLSerializer().Parse(MLSerializer.SerializerType.XML, strFileName);
foreach (MLNode objMLNode in objMLFile.Nodes)
{
if (objMLNode.Name == cnstStrTagRoot)
{ // Añade los parámetros básicos
objProject.IDType = (ProjectDocumentationModel.DocumentationType)objMLNode.Nodes[cnstStrTagDocumentationType].Value.GetInt(0);
objProject.OutputPath = objMLNode.Nodes[cnstStrTagProviderPath].Value;
objProject.TemplatePath = objMLNode.Nodes[cnstStrTagProviderTemplatePath].Value;
objProject.GenerationParameters.ShowPublic = objMLNode.Nodes[cnstStrTagShowPublic].Value.GetBool();
objProject.GenerationParameters.ShowProtected = objMLNode.Nodes[cnstStrTagShowProtected].Value.GetBool();
objProject.GenerationParameters.ShowInternal = objMLNode.Nodes[cnstStrTagShowInternal].Value.GetBool();
objProject.GenerationParameters.ShowPrivate = objMLNode.Nodes[cnstStrTagShowPrivate].Value.GetBool();
// Añade los proveedores
foreach (MLNode objMLChild in objMLNode.Nodes)
{
if (objMLChild.Name == cnstStrTagProvider)
{
objProject.Providers.Add(LoadProvider(objMLChild));
}
}
}
}
}
// Devuelve el proyecto
return(objProject);
}
public override void Serialize(MLSerializer ser)
{
base.Serialize(ser);
ser.Write("CLASSES", Classes.Select(c => c.Name));
}
public override void Serialize(MLSerializer ser)
{
ser.Write("SUB_ALGORITHM", m_SubAlgorithm);
}
public virtual void Serialize(MLSerializer ser)
{
ser.Write("TYPE", GetType().FullName);
}
public override void Deserialize(MLSerializer ser)
{
throw new NotImplementedException();
}
public override void Deserialize(MLSerializer ser)
{
m_SubAlgorithm = ser.ReadMLSerializable("SUB_ALGORITHM") as IClassificationAlgorithm <double[]>;
}
