// save model as binary format
public override void SaveModel(string filename)
{
var sw = new StreamWriter(filename);
var fo = new BinaryWriter(sw.BaseStream);
fo.Write(IsCRFTraining);
fo.Write(HiddenLayerList.Count);
foreach (var layer in HiddenLayerList)
{
fo.Write((int)layer.LayerType);
layer.Save(fo);
}
fo.Write((int)OutputLayer.LayerType);
OutputLayer.Save(fo);
if (IsCRFTraining)
{
//Save CRF feature weights
RNNHelper.SaveMatrix(CRFTagTransWeights, fo);
}
fo.Close();
}
public override void LoadModel(string filename, bool bTrain = false)
{
Logger.WriteLine(Logger.Level.info, "Loading bi-directional model: {0}", filename);
using (var sr = new StreamReader(filename))
{
var br = new BinaryReader(sr.BaseStream);
IsCRFTraining = br.ReadBoolean();
var layerSize = br.ReadInt32();
LayerType layerType = LayerType.None;
//Load forward layers from file
forwardHiddenLayers = new List <SimpleLayer>();
for (var i = 0; i < layerSize; i++)
{
layerType = (LayerType)br.ReadInt32();
forwardHiddenLayers.Add(Load(layerType, br));
SimpleLayer layer = forwardHiddenLayers[forwardHiddenLayers.Count - 1];
if (bTrain)
{
layer.SetRunningMode(RunningMode.Training);
layer.InitializeInternalTrainingParameters();
}
else
{
layer.SetRunningMode(RunningMode.Test);
}
}
//Load backward layers from file
backwardHiddenLayers = new List <SimpleLayer>();
for (var i = 0; i < layerSize; i++)
{
layerType = (LayerType)br.ReadInt32();
backwardHiddenLayers.Add(Load(layerType, br));
SimpleLayer layer = backwardHiddenLayers[backwardHiddenLayers.Count - 1];
if (bTrain)
{
layer.SetRunningMode(RunningMode.Training);
layer.InitializeInternalTrainingParameters();
}
else
{
layer.SetRunningMode(RunningMode.Test);
}
}
Logger.WriteLine("Create output layer");
layerType = (LayerType)br.ReadInt32();
OutputLayer = Load(layerType, br);
if (bTrain)
{
OutputLayer.SetRunningMode(RunningMode.Training);
OutputLayer.InitializeInternalTrainingParameters();
}
else
{
OutputLayer.SetRunningMode(RunningMode.Test);
}
if (IsCRFTraining)
{
Logger.WriteLine("Loading CRF tag trans weights...");
CRFWeights = RNNHelper.LoadMatrix(br);
}
if (bTrain)
{
InitCache(forwardHiddenLayers, backwardHiddenLayers, OutputLayer.CreateLayerSharedWegiths());
}
}
}
// private static object lockerCRF = new object();
public void UpdateBigramTransition(Sequence seq)
{
var OutputLayerSize = OutputLayer.LayerSize;
var numStates = seq.States.Length;
crfWeightsDelta.Clean();
for (var timeat = 1; timeat < numStates; timeat++)
{
var CRFSeqOutput_timeat = CRFSeqOutput[timeat];
var CRFSeqOutput_pre_timeat = CRFSeqOutput[timeat - 1];
for (var i = 0; i < OutputLayerSize; i++)
{
var CRFSeqOutput_timeat_i = CRFSeqOutput_timeat[i];
var CRFTagTransWeights_i = CRFWeights[i];
var crfWeightsDelta_i = crfWeightsDelta[i];
var j = 0;
var vecCRFSeqOutput_timeat_i = new Vector <float>(CRFSeqOutput_timeat_i);
var moreItems = (OutputLayerSize % Vector <float> .Count);
while (j < OutputLayerSize - moreItems)
{
var v1 = new Vector <float>(CRFTagTransWeights_i, j);
var v2 = new Vector <float>(CRFSeqOutput_pre_timeat, j);
var v = new Vector <float>(crfWeightsDelta_i, j);
v -= v1 * vecCRFSeqOutput_timeat_i * v2;
v.CopyTo(crfWeightsDelta_i, j);
j += Vector <float> .Count;
}
while (j < OutputLayerSize)
{
crfWeightsDelta_i[j] -= CRFTagTransWeights_i[j] * CRFSeqOutput_timeat_i * CRFSeqOutput_pre_timeat[j];
j++;
}
}
var iTagId = seq.States[timeat].Label;
var iLastTagId = seq.States[timeat - 1].Label;
crfWeightsDelta[iTagId][iLastTagId] += 1;
}
//Update tag Bigram LM
for (var i = 0; i < OutputLayerSize; i++)
{
var CRFWeights_i = CRFWeights[i];
var CRFWeightsDelta_i = crfWeightsDelta[i];
var j = 0;
var moreItems = (OutputLayerSize % Vector <float> .Count);
while (j < OutputLayerSize - moreItems)
{
var vecDelta = new Vector <float>(CRFWeightsDelta_i, j);
//Normalize delta
vecDelta = RNNHelper.NormalizeGradient(vecDelta);
//Update weights
var vecWeights = new Vector <float>(CRFWeights_i, j);
vecWeights += RNNHelper.vecNormalLearningRate * vecDelta;
vecWeights.CopyTo(CRFWeights_i, j);
j += Vector <float> .Count;
}
while (j < OutputLayerSize)
{
var delta = CRFWeightsDelta_i[j];
delta = RNNHelper.NormalizeGradient(delta);
CRFWeights_i[j] += RNNHelper.LearningRate * delta;
j++;
}
}
}
