private void setupBtmTop(Blob <T> btm, Blob <T> top)
{
m_rgBtm.Clear();
m_rgBtm.Add(btm);
m_rgTop.Clear();
m_rgTop.Add(top);
}
private void addInternal(Blob <T> bottom, Blob <T> top)
{
m_colInternalBottom.Clear();
m_colInternalBottom.Add(bottom);
m_colInternalTop.Clear();
m_colInternalTop.Add(top);
}
public ActionResult SendPDF(string formXml, string xsnName, string viewName, string toEmail, string emailBody)
{
var spContext = SharePointContextProvider.Current.GetSharePointContext(System.Web.HttpContext.Current);
using (var clientContext = spContext.CreateUserClientContextForSPHost())
{
SP.User spUser = GetSharePointUser(clientContext);
string internalUserID = null;
// Store data for processing
string tenantID = TokenHelper.GetRealmFromTargetUrl(new Uri(clientContext.Url));
RequestIdentifier rid = RequestUtil.AddRequestEntity(PdfRequestType.SendPDF, PdfRequestStatus.InProgress, tenantID, internalUserID);
PDFRequest response = new PDFRequest();
response.RequestID = rid.ID;
response.RequestType = PdfRequestType.SendPDF;
response.Status = PdfRequestStatus.InProgress;
response.Message = "";
BlobUtil bu = null;
try
{
bu = new BlobUtil();
ParameterCollection plist = new ParameterCollection();
plist.Add(Parameters.Api, "SendPDF");
plist.Add(Parameters.ViewName, viewName ?? "");
plist.Add(Parameters.UserID, internalUserID);
plist.Add(Parameters.XsnName, xsnName ?? "");
plist.Add(Parameters.FromEmail, spUser.Email ?? "");
plist.Add(Parameters.ToEmail, toEmail ?? "");
plist.Add(Parameters.EmailBody, emailBody ?? "");
BlobCollection bc = new BlobCollection();
bc.Add("xml", formXml);
bc.Add("parameters", plist);
bu.StoreRequestArguments(rid.ID, bc);
// post to queue
PdfServiceQueues.XmlToHtmlClient.AddMessage(rid.ID, internalUserID);
}
catch (Exception ex)
{
// Update request status
response.Status = PdfRequestStatus.Error;
response.Message = ex.Message;
RequestUtil.UpdateRequestStatus(rid.ID, PdfRequestStatus.Error, ex.Message);
//PdfServiceQueues.EmailSendClient.AddErrorMessage(requestID, internalUserID.Value, ex.Message);
}
finally
{
}
return(new ObjectResult <PDFRequest>(response));
}
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
DataNormalizerParameter p = m_param.data_normalizer_param;
if (p.steps.Count == 0)
{
m_log.WriteLine("WARNING: No normalization steps are specified, data will just pass through in its normal form.");
}
if (p.steps.Contains(DataNormalizerParameter.NORMALIZATION_STEP.RANGE))
{
double dfRange = p.output_max - p.output_min;
m_log.CHECK_GT(dfRange, 0, "The output data range must be greater than 0!");
}
if (p.steps.Contains(DataNormalizerParameter.NORMALIZATION_STEP.STDEV))
{
if (p.input_stdev.HasValue)
{
m_log.CHECK_NE(p.input_stdev.Value, 0, "The standard deviation cannot be zero!");
}
}
for (int i = 0; i < colBottom.Count; i++)
{
m_colWork1.Add(new Blob <T>(m_cuda, m_log, colBottom[i]));
m_colWork2.Add(new Blob <T>(m_cuda, m_log, colBottom[i]));
}
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
if (m_phase == Phase.TEST || m_phase == Phase.TRAIN)
{
m_log.CHECK_EQ(2, colBottom.Count, "There should be two bottom items: data (embeddings) and labels.");
}
m_nBatchSize = colBottom[0].shape(0);
// Allocate the temp batch storage.
for (int i = 0; i < m_nMaxBatches; i++)
{
Blob <T> data = new Blob <T>(m_cuda, m_log, false);
data.ReshapeLike(colBottom[0]);
m_rgBatchData.Add(data);
}
// Setup the weights (which stores the centroid embedding for each class)
Blob <T> blobCentroid = new Blob <T>(m_cuda, m_log);
List <int> rgShape = Utility.Clone <int>(colBottom[0].shape());
rgShape[0] = m_nNumOutput;
blobCentroid.Reshape(rgShape);
m_colBlobs.Add(blobCentroid);
for (int i = 0; i < colBottom.Count; i++)
{
m_param.propagate_down.Add(false);
}
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
base.LayerSetUp(colBottom, colTop);
// Internal softmax layer.
LayerParameter softmax_param = new LayerParameter(LayerParameter.LayerType.SOFTMAX);
softmax_param.softmax_param.axis = m_param.infogain_loss_param.axis;
softmax_param.loss_weight.Clear();
softmax_param.loss_weight.Add(1);
m_softmaxLayer = new SoftmaxLayer <T>(m_cuda, m_log, softmax_param);
m_colSoftmaxBottomVec.Clear();
m_colSoftmaxBottomVec.Add(colBottom[0]);
m_colSoftmaxTopVec.Clear();
m_colSoftmaxTopVec.Add(m_blobProb);
m_softmaxLayer.Setup(m_colSoftmaxBottomVec, m_colSoftmaxTopVec);
// ignore label.
m_nIgnoreLabel = m_param.loss_param.ignore_label;
// normalization
m_log.CHECK(!m_param.loss_param.normalize, "normalize is drepreciated, use 'normalization'.");
m_normalization = m_param.loss_param.normalization;
// matrix H
if (colBottom.Count < 3)
{
m_log.CHECK(m_param.infogain_loss_param.source != null, "Infogain matrix source must be specified.");
PersistCaffe <T> persist = new PersistCaffe <T>(m_log, true);
BlobProto blobProto = persist.LoadBlobProto(m_param.infogain_loss_param.source, 1);
m_blobInfoGain.FromProto(blobProto);
}
}
/// <summary>
/// The PreprocessInput allows derivative data layers to convert a property set of input
/// data into the bottom blob collection used as intput.
/// </summary>
/// <param name="customInput">Specifies the custom input data.</param>
/// <param name="colBottom">Optionally, specifies the bottom data to fill.</param>
/// <returns>The bottom data is returned.</returns>
/// <remarks>The blobs returned should match the blob descriptions returned in the LayerParameter's
/// overrides for 'PrepareRunModelInputs' and 'PrepareRunModel'.</remarks>
public override BlobCollection <T> PreProcessInput(PropertySet customInput, BlobCollection <T> colBottom = null)
{
if (colBottom == null)
{
string strInput = m_param.PrepareRunModelInputs();
RawProto proto = RawProto.Parse(strInput);
Dictionary <string, BlobShape> rgInput = NetParameter.InputFromProto(proto);
colBottom = new BlobCollection <T>();
foreach (KeyValuePair <string, BlobShape> kv in rgInput)
{
Blob <T> blob = new Blob <T>(m_cuda, m_log);
blob.Name = kv.Key;
blob.Reshape(kv.Value);
colBottom.Add(blob);
}
}
string strEncInput = customInput.GetProperty("InputData");
if (strEncInput == null)
{
throw new Exception("Could not find the expected input property 'InputData'!");
}
PreProcessInput(strEncInput, null, colBottom);
return(colBottom);
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
base.LayerSetUp(colBottom, colTop);
LayerParameter p = m_param.Clone(false);
p.type = LayerParameter.LayerType.SOFTMAX;
m_softmaxLayer = new SoftmaxLayer <T>(m_cuda, m_log, p);
m_colSoftmaxBottom = new BlobCollection <T>();
m_colSoftmaxTop = new BlobCollection <T>();
m_colSoftmaxBottom.Add(colBottom[0]);
m_colSoftmaxTop.Add(m_blobProb);
m_softmaxLayer.Setup(m_colSoftmaxBottom, m_colSoftmaxTop);
m_nIgnoreLabel = m_param.loss_param.ignore_label;
if (m_param.loss_param.normalization == LossParameter.NormalizationMode.NONE)
{
m_normalization = (m_param.loss_param.normalize) ? LossParameter.NormalizationMode.VALID : LossParameter.NormalizationMode.BATCH_SIZE;
}
else
{
m_normalization = m_param.loss_param.normalization;
}
}
public void SaveFavorites()
{
BlobCollection blobs = new BlobCollection();
foreach (string applicationName in _favoritesUpdateCache.Keys)
{
ShellDrillDownMenuItem favoritesMenu = _favoritesUpdateCache[applicationName];
XmlDocument xmlDocument = XmlToShellDrillDownMenuItemTransformer.Transform(favoritesMenu);
Blob blob = CreateBlob(applicationName, xmlDocument);
if (blob != null)
{
blobs.Add(blob);
}
}
CreateOrUpdateBlobParameters parameters = new CreateOrUpdateBlobParameters
{
ContainerName = GetContainerName(),
Blobs = blobs
};
CreateOrUpdateBlobRequest request = new CreateOrUpdateBlobRequest();
request.CreateOrUpdateBlobParameters = parameters;
SettingsService.CreateOrUpdateBlob(request);
}
public InputLayerEx(CudaDnn <T> cuda, Log log, Layer <T> layer) : base(cuda, log, layer.layer_param)
{
string strPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
strPath += "\\mycaffe\\test_data\\data\\text\\";
LayerParameter text_param = new LayerParameter(LayerParameter.LayerType.TEXT_DATA);
text_param.text_data_param.batch_size = 1;
text_param.text_data_param.decoder_source = strPath + "robot_text.txt";
text_param.text_data_param.encoder_source = strPath + "human_text.txt";
text_param.text_data_param.enable_normal_encoder_output = true;
text_param.text_data_param.enable_reverse_encoder_output = true;
text_param.text_data_param.sample_size = 1000;
text_param.text_data_param.shuffle = false;
text_param.text_data_param.time_steps = 80;
text_param.phase = Phase.TEST;
m_dataLayer = new TextDataLayer <T>(cuda, log, text_param);
BlobCollection <T> colBottom = new BlobCollection <T>();
BlobCollection <T> colTop = new BlobCollection <T>();
colTop.Add(new Blob <T>(cuda, log));
colTop.Add(new Blob <T>(cuda, log));
colTop.Add(new Blob <T>(cuda, log));
colTop.Add(new Blob <T>(cuda, log));
colTop.Add(new Blob <T>(cuda, log));
colTop.Add(new Blob <T>(cuda, log));
colTop.Add(new Blob <T>(cuda, log));
m_dataLayer.Setup(colBottom, colTop);
colTop.Dispose();
}
protected virtual void LoadHDF5FileData(string strFile)
{
m_log.WriteLine("Loading HDF5 file: '" + strFile + "'");
HDF5 <T> hdf5 = new HDF5 <T>(m_cuda, m_log, strFile);
int nTopCount = m_param.top.Count;
for (int i = 0; i < nTopCount; i++)
{
// Allow reshape here, as we are loading data not params.
Blob <T> blob = null;
if (m_colHdfBlobs.Count < nTopCount)
{
blob = new Blob <T>(m_cuda, m_log, false);
m_colHdfBlobs.Add(blob);
}
else
{
blob = m_colHdfBlobs[i];
}
blob.Name = m_param.top[i];
hdf5.load_nd_dataset(blob, m_param.top[i], true);
}
hdf5.Dispose();
// MinTopBlobs=1 guarantees at least one top blob
m_log.CHECK_GE(m_colHdfBlobs[0].num_axes, 1, "Input must have at least 1 axis.");
int nNum = m_colHdfBlobs[0].shape(0);
for (int i = 1; i < nTopCount; i++)
{
m_log.CHECK_EQ(m_colHdfBlobs[i].shape(0), nNum, "The 'num' on all blobs must be equal.");
}
// Default to identity permutation.
m_rgDataPermutation = new List <int>();
for (int i = 0; i < nNum; i++)
{
m_rgDataPermutation.Add(i);
}
// Shuffle if needed
if (m_param.hdf5_data_param.shuffle)
{
m_rgDataPermutation = Utility.RandomShuffle(m_rgDataPermutation);
m_log.WriteLine("Successfully loaded " + nNum.ToString() + " rows (shuffled).");
}
else
{
m_log.WriteLine("Successfully loaded " + nNum.ToString() + " rows.");
}
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
base.LayerSetUp(colBottom, colTop);
m_colSigmoidBottom.Clear();
m_colSigmoidBottom.Add(m_blobSigmoidInput);
m_colSigmoidTop.Clear();
m_colSigmoidTop.Add(m_blobSigmoidOutput);
m_sigmoidLayer.LayerSetUp(m_colSigmoidBottom, m_colSigmoidTop);
}
/// <summary>
/// Load the data into the model.
/// </summary>
/// <param name="strInput">Specifies the encoder input sentence.</param>
/// <param name="nIxInput">Specifies the decoder current input word index.</param>
private BlobCollection <float> loadData(string strInput, int nIxInput)
{
Net <float> net = m_mycaffe.GetInternalNet(Phase.RUN);
TextDataLayer <float> layer = net.FindLayer("TextData", "data") as TextDataLayer <float>;
Blob <float> blobData = net.FindBlob("ienc");
Blob <float> blobDatar = net.FindBlob("iencr");
Blob <float> blobClipE = net.FindBlob("iencc");
Blob <float> blobDecInput = net.FindBlob("idec");
BlobCollection <float> colBtm = new BlobCollection <float>();
colBtm.Add(blobDecInput);
colBtm.Add(blobData);
colBtm.Add(blobDatar);
colBtm.Add(blobClipE);
layer.PreProcessInput(strInput, nIxInput, colBtm);
return(colBtm);
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
base.LayerSetUp(colBottom, colTop);
m_colSoftmaxBottomVec = new BlobCollection <T>();
m_colSoftmaxBottomVec.Add(colBottom[0]);
m_colSoftmaxTopVec = new BlobCollection <T>();
m_colSoftmaxTopVec.Add(m_blobSoftmaxOutput);
m_softmaxLayer.Setup(m_colSoftmaxBottomVec, m_colSoftmaxTopVec);
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
if (colBottom.Count == 1 && m_colBlobs.Count > 0)
{
m_log.WriteLine("Skipping parameter initialization.");
}
else if (colBottom.Count == 1)
{
// bias is a learned parameter; initialize it.
BiasParameter p = m_param.bias_param;
int nAxis = colBottom[0].CanonicalAxisIndex(p.axis);
int nNumAxes = p.num_axes;
m_log.CHECK_GE(nNumAxes, -1, "num_axes must be non-negative, or -1 to extend to end of bottom[0].");
if (nNumAxes >= 0)
{
m_log.CHECK_GE(colBottom[0].num_axes, nAxis + nNumAxes, "bias blob's shape extends past bottom[0]'s shape when applied starting with bottom[0] axis = " + nAxis.ToString());
}
m_colBlobs = new BlobCollection <T>();
List <int> rgBiasShape = new List <int>();
int nStart = nAxis;
int nEnd = (nNumAxes == -1) ? colBottom[0].shape().Count : nStart + nNumAxes;
for (int i = nStart; i < nEnd; i++)
{
rgBiasShape.Add(colBottom[0].shape(i));
}
Blob <T> blobBias = new Blob <T>(m_cuda, m_log);
blobBias.Name = m_param.name + " bias";
blobBias.type = BLOB_TYPE.INTERNAL;
blobBias.type = BLOB_TYPE.WEIGHT;
if (!shareParameter(blobBias, rgBiasShape))
{
blobBias.Reshape(rgBiasShape);
FillerParameter fp = p.filler;
if (fp == null)
{
fp = new FillerParameter("constant", 0.0);
}
Filler <T> filler = Filler <T> .Create(m_cuda, m_log, fp);
filler.Fill(blobBias);
}
m_colBlobs.Add(blobBias);
}
m_rgbParamPropagateDown = new DictionaryMap <bool>(m_colBlobs.Count, true);
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
base.LayerSetUp(colBottom, colTop);
m_colSigmoidBottomVec.Clear();
m_colSigmoidBottomVec.Add(colBottom[0]);
m_colSigmoidTopVec.Clear();
m_colSigmoidTopVec.Add(m_blobSigmoidOutput);
m_sigmoidLayer.Setup(m_colSigmoidBottomVec, m_colSigmoidTopVec);
m_nIgnoreLabel = m_param.loss_param.ignore_label;
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
m_log.CHECK_GE(colBottom.Count, 2, "There should be at least two bottom items: data (embeddings) and labels.");
m_log.CHECK_EQ(colTop.Count, colBottom.Count - 1, "The top count should equal the bottom count - 1");
// Allocate the temp batch storage.
for (int i = 0; i < m_nMaxBatches; i++)
{
Blob <T> data = new Blob <T>(m_cuda, m_log);
data.ReshapeLike(colBottom[0]);
m_rgBatchData.Add(data);
Blob <T> label = new common.Blob <T>(m_cuda, m_log, false);
label.ReshapeLike(colBottom[1]);
m_rgBatchLabels.Add(label);
}
}
/// <summary>
/// Runs the pre-solve which parpares the Solver to start Solving.
/// </summary>
public void PreSolve()
{
BlobCollection <T> colNetParams = m_net.learnable_parameters;
m_colHistory.Clear(true);
// m_colUpdate.Clear(true);
m_colTemp.Clear(true);
for (int i = 0; i < colNetParams.Count; i++)
{
List <int> rgShape = colNetParams[i].shape();
m_colHistory.Add(new Blob <T>(m_cuda, m_log, rgShape, false)); // diff never used
// m_colUpdate.Add(new Blob<T>(m_cuda, m_log, rgShape, false));
m_colTemp.Add(new Blob <T>(m_cuda, m_log, rgShape, false)); // diff never used
}
}
/// <summary>
/// Runs the pre-solve which parpares the Solver to start Solving.
/// </summary>
public void PreSolve()
{
BlobCollection <T> net_params = m_net.learnable_parameters;
m_nN = 0;
for (int i = 0; i < net_params.Count; i++)
{
if (m_net.params_lr[i] != 0)
{
m_nN += net_params[i].count();
}
}
// Nothing to do, all learnable parameters have lr_mult = 0
if (m_nN == 0)
{
return;
}
List <int> rgShape = new List <int>()
{
m_nN
};
m_colBlobHistoryS.Clear();
m_colBlobHistoryY.Clear();
m_rgRhoHistory.Clear();
m_nStart = 0;
m_nEnd = -1;
m_blobGradients = new Blob <T>(m_cuda, m_log, rgShape, false);
m_blobGradients.Name = "gradients";
m_blobGradientsPrev = new Blob <T>(m_cuda, m_log, rgShape, false);
m_blobGradientsPrev.Name = "gradients prev";
m_blobDirection = new Blob <T>(m_cuda, m_log, rgShape, false);
m_blobDirection.Name = "direction";
for (int i = 0; i < m_param.lbgfs_corrections; i++)
{
m_colBlobHistoryS.Add(new Blob <T>(m_cuda, m_log, rgShape, false));
m_colBlobHistoryY.Add(new Blob <T>(m_cuda, m_log, rgShape, false));
m_rgRhoHistory.Add(0);
}
}
/// <summary>
/// The Layer constructor.
/// </summary>
/// <remarks>
/// Setup code for derivative classes should go into an override of the LayerSetup function where the
/// dimensionsn of the Blob%s are provided to the Layer.
/// </remarks>
/// <param name="cuda">Specifies the CudaDnn connection to Cuda.</param>
/// <param name="log">Specifies the Log for output.</param>
/// <param name="p">Specifies the LayerParameter that contains the settings of the Layer.</param>
public Layer(CudaDnn <T> cuda, Log log, LayerParameter p)
{
m_cuda = cuda;
m_log = log;
m_param = p.Clone(true);
m_phase = p.phase;
m_rgbParamPropagateDown = new DictionaryMap <bool>(false);
m_rgLoss = new DictionaryMap <double>(0.0);
m_colBlobs = new BlobCollection <T>();
for (int i = 0; i < p.blobs.Count; i++)
{
m_colBlobs.Add(new Blob <T>(cuda, log, p.blobs[i]));
}
m_tOne = (T)Convert.ChangeType(1, typeof(T));
m_tZero = (T)Convert.ChangeType(0, typeof(T));
}
protected void SaveOrUpdateDefaultUser(string user)
{
BlobCollection blobs = new BlobCollection();
blobs.Add(CreateBlob(user));
CreateOrUpdateBlobParameters parameters = new CreateOrUpdateBlobParameters
{
ContainerName = GetContainerName(),
Blobs = blobs
};
CreateOrUpdateBlobRequest request = new CreateOrUpdateBlobRequest();
request.CreateOrUpdateBlobParameters = parameters;
SettingsService.CreateOrUpdateBlob(request);
}
public void SaveSettings()
{
if (string.IsNullOrEmpty(ContainerName))
{
throw new ArgumentNullException("ContainerName");
}
BlobCollection blobs = new BlobCollection();
foreach (KeyValuePair <object, ISettingsProvider> providerEntry in _providerDictionary)
{
object settings = providerEntry.Value.SaveSettings(providerEntry.Key);
Blob blob = CreateBlob(providerEntry.Value.GetKey(providerEntry.Key), settings);
if (blob != null)
{
blobs.Add(blob);
}
}
if (_useBackgroundThread)
{
ThreadPool.QueueUserWorkItem((s) =>
{
try
{
CreateOrUpdateBlob(blobs);
}
catch (Exception ex)
{
_synchronizationContext.Send((state) =>
{
throw ex;
}, null);
}
});
}
else
{
CreateOrUpdateBlob(blobs);
}
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
base.LayerSetUp(colBottom, colTop);
LayerParameter param_softmax = m_param.Clone(false);
param_softmax.SetType(LayerParameter.LayerType.SOFTMAX);
param_softmax.softmax_param = m_param.softmax_param.Clone() as SoftmaxParameter;
param_softmax.loss_weight.Clear();
m_softmaxLayer = new SoftmaxLayer <T>(m_cuda, m_log, param_softmax);
m_colSoftmaxBottom = new BlobCollection <T>();
m_colSoftmaxTop = new BlobCollection <T>();
m_colSoftmaxBottom.Add(colBottom[0]);
m_colSoftmaxTop.Add(m_blobProb);
m_softmaxLayer.Setup(m_colSoftmaxBottom, m_colSoftmaxTop);
m_nIgnoreLabel = m_param.loss_param.ignore_label;
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
base.LayerSetUp(colBottom, colTop);
m_colSigmoidBottomVec = new BlobCollection <T>();
m_colSigmoidBottomVec.Add(colBottom[0]);
m_colSigmoidTopVec = new BlobCollection <T>();
m_colSigmoidTopVec.Add(m_blobSigmoidOutput);
m_sigmoidLayer.Setup(m_colSigmoidBottomVec, m_colSigmoidTopVec);
m_nIgnoreLabel = m_param.loss_param.ignore_label;
if (m_param.loss_param.normalization != LossParameter.NormalizationMode.NONE)
{
m_normalization = m_param.loss_param.normalization;
}
else
{
m_normalization = (m_param.loss_param.normalize) ? LossParameter.NormalizationMode.VALID : LossParameter.NormalizationMode.BATCH_SIZE;
}
}
public TestEx(string strName, List <int> rgBottomShape = null, int nDeviceID = TestBase.DEFAULT_DEVICE_ID)
: base(strName, nDeviceID)
{
if (rgBottomShape == null)
{
rgBottomShape = new List <int>()
{
2, 3, 4, 5
}
}
;
m_blob_bottom = new Blob <T>(m_cuda, m_log, rgBottomShape);
m_blob_top = new Blob <T>(m_cuda, m_log);
m_colBottom.Add(m_blob_bottom);
m_colTop.Add(m_blob_top);
FillerParameter fp = getFillerParam();
m_filler = Filler <T> .Create(m_cuda, m_log, fp);
m_filler.Fill(m_blob_bottom);
}
/// <summary>
/// Setup the layer for both Engine.CUDNN and Engine.CAFFE modes.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
m_nSize = (int)m_param.lrn_param.local_size;
m_log.CHECK_EQ(m_nSize % 2, 1, "LRN only supports odd values for local_size.");
m_nPrePad = (m_nSize - 1) / 2;
m_dfAlpha = m_param.lrn_param.alpha;
m_dfBeta = m_param.lrn_param.beta;
m_dfK = m_param.lrn_param.k;
if (m_param.lrn_param.norm_region == LRNParameter.NormRegion.WITHIN_CHANNEL)
{
// Set up split_layer to use in the numerator and denominator.
m_colSplitTopVec = new BlobCollection <T>();
m_colSplitTopVec.Add(m_blobProductInput);
m_colSplitTopVec.Add(m_blobSquareInput);
LayerParameter split_param = new LayerParameter(LayerParameter.LayerType.SPLIT, "split");
m_splitLayer = new SplitLayer <T>(m_cuda, m_log, split_param);
m_splitLayer.Setup(colBottom, m_colSplitTopVec);
// Set up square_layer to square teh inputs.
m_colSquareBottomVec = new BlobCollection <T>();
m_colSquareTopVec = new BlobCollection <T>();
m_colSquareBottomVec.Add(m_blobSquareInput);
m_colSquareTopVec.Add(m_blobSquareOutput);
LayerParameter square_param = new LayerParameter(LayerParameter.LayerType.POWER, "square");
square_param.power_param.power = 2.0;
m_squareLayer = new PowerLayer <T>(m_cuda, m_log, square_param);
m_squareLayer.Setup(m_colSquareBottomVec, m_colSquareTopVec);
// Set up pool_layer to sum over square neighborhoods of the input.
m_colPoolTopVec = new BlobCollection <T>();
m_colPoolTopVec.Add(m_blobPoolOutput);
LayerParameter pool_param = new LayerParameter(LayerParameter.LayerType.POOLING, "pool");
pool_param.pooling_param.pool = PoolingParameter.PoolingMethod.AVE;
pool_param.pooling_param.pad.Add((uint)m_nPrePad);
pool_param.pooling_param.kernel_size.Add((uint)m_nSize);
m_poolLayer = new PoolingLayer <T>(m_cuda, m_log, pool_param);
m_poolLayer.Setup(m_colSquareTopVec, m_colPoolTopVec);
// Set up power_layer to compute (1 + alpha/N^2 s)^-beta, where s is
// the sum of the squared neighborhood (the output of pool_layer)
m_colPowerTopVec = new BlobCollection <T>();
m_colPowerTopVec.Add(m_blobPowerOutput);
LayerParameter power_param = new LayerParameter(LayerParameter.LayerType.POWER, "power");
power_param.power_param.power = -m_dfBeta;
power_param.power_param.scale = m_dfAlpha;
power_param.power_param.shift = 1.0;
m_powerLayer = new PowerLayer <T>(m_cuda, m_log, power_param);
m_powerLayer.Setup(m_colPoolTopVec, m_colPowerTopVec);
// Set up a product_layer to compute outputs by multiplying inputs by the
// inverse denominator computed by the power layer.
m_colProductBottomVec = new BlobCollection <T>();
m_colProductBottomVec.Add(m_blobProductInput);
m_colProductBottomVec.Add(m_blobPowerOutput);
LayerParameter product_param = new LayerParameter(LayerParameter.LayerType.ELTWISE, "product");
product_param.eltwise_param.operation = EltwiseParameter.EltwiseOp.PROD;
m_productLayer = new EltwiseLayer <T>(m_cuda, m_log, product_param);
m_productLayer.Setup(m_colProductBottomVec, colTop);
}
if (!m_param.lrn_param.useCudnn())
{
return;
}
m_hCuDnn = m_cuda.CreateCuDNN();
m_hNormDesc = m_cuda.CreateLRNDesc();
m_hBottomDesc = m_cuda.CreateTensorDesc();
m_hTopDesc = m_cuda.CreateTensorDesc();
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
m_dfClippingThreshold = m_param.lstm_simple_param.clipping_threshold;
m_nN = (int)m_param.lstm_simple_param.batch_size; // batch size.
m_nH = (int)m_param.lstm_simple_param.num_output; // number of hidden units.
m_nI = (int)(colBottom[0].count() / colBottom[0].num); // input dimension.
// Check if we need to set up the weights.
if (m_colBlobs.Count > 0)
{
m_log.WriteLine("Skipping parameter initialization.");
}
else
{
m_colBlobs = new BlobCollection <T>();
Filler <T> weight_filler = Filler <T> .Create(m_cuda, m_log, m_param.lstm_simple_param.weight_filler);
Filler <T> bias_filler = Filler <T> .Create(m_cuda, m_log, m_param.lstm_simple_param.bias_filler);
// input-to-hidden weights
// Initialize the weight.
List <int> rgShape1 = new List <int>()
{
4 * m_nH, m_nI
};
Blob <T> blobWeights_I_H = new Blob <T>(m_cuda, m_log);
blobWeights_I_H.Name = m_param.name + " weights I to H";
blobWeights_I_H.type = Blob <T> .BLOB_TYPE.WEIGHT;
if (!shareParameter(blobWeights_I_H, rgShape1))
{
blobWeights_I_H.Reshape(rgShape1);
weight_filler.Fill(blobWeights_I_H);
}
m_colBlobs.Add(blobWeights_I_H);
// hidden-to-hidden weights
// Initialize the weight.
List <int> rgShape2 = new List <int>()
{
4 * m_nH, m_nH
};
Blob <T> blobWeights_H_H = new Blob <T>(m_cuda, m_log);
blobWeights_H_H.Name = m_param.name + " weights H to H";
blobWeights_H_H.type = Blob <T> .BLOB_TYPE.WEIGHT;
if (!shareParameter(blobWeights_H_H, rgShape2))
{
blobWeights_H_H.Reshape(rgShape2);
weight_filler.Fill(blobWeights_H_H);
}
m_colBlobs.Add(blobWeights_H_H);
// If necessary, initialize and fill the bias term.
List <int> rgShape3 = new List <int>()
{
4 * m_nH
};
Blob <T> blobBias = new Blob <T>(m_cuda, m_log);
blobBias.Name = m_param.name + " bias weights";
blobBias.type = Blob <T> .BLOB_TYPE.WEIGHT;
if (!shareParameter(blobBias, rgShape3))
{
blobBias.Reshape(rgShape3);
bias_filler.Fill(blobBias);
}
m_colBlobs.Add(blobBias);
// Initialize the bias for the forget gate to 5.0 as described in the
// Clockwork RNN paper:
// [1] Koutnik, J., Greff, K., Gomez, F., Schmidhuber, J., 'A Clockwork RNN', 2014"
if (m_param.lstm_simple_param.enable_clockwork_forgetgate_bias)
{
double[] rgBias = convertD(blobBias.mutable_cpu_data);
for (int i = m_nH; i < 2 * m_nH; i++)
{
rgBias[i] = 5.0;
}
blobBias.mutable_cpu_data = convert(rgBias);
}
}
m_rgbParamPropagateDown = new DictionaryMap <bool>(m_colBlobs.Count, true);
List <int> rgCellShape = new List <int>()
{
m_nN, m_nH
};
m_blob_C_0.Reshape(rgCellShape);
m_blob_H_0.Reshape(rgCellShape);
m_blob_C_T.Reshape(rgCellShape);
m_blob_H_T.Reshape(rgCellShape);
m_blob_H_to_H.Reshape(rgCellShape);
List <int> rgGateShape = new List <int>()
{
m_nN, 4, m_nH
};
m_blob_H_to_Gate.Reshape(rgGateShape);
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
ScaleParameter p = m_param.scale_param;
if (colBottom.Count == 1 && blobs.Count > 0)
{
m_log.WriteLine("Skipping parameter initialization.");
}
else if (colBottom.Count == 1)
{
// scale is a learned parameter; initialize it.
m_nAxis = colBottom[0].CanonicalAxisIndex(p.axis);
int nNumAxes = p.num_axes;
m_log.CHECK_GE(nNumAxes, -1, "num_axes must be non-negative, or -1 to extend to the end of bottom[0].");
if (nNumAxes >= 0)
{
m_log.CHECK_GE(colBottom[0].num_axes, m_nAxis + nNumAxes, "scale blob's shape extends past bottom[0]'s shape when applied starting with bottom[0] axis = " + m_nAxis.ToString());
}
m_colBlobs = new BlobCollection <T>();
List <int> rgShape = new List <int>();
int nStart = m_nAxis;
int nEnd = (nNumAxes == -1) ? colBottom[0].shape().Count : nStart + nNumAxes;
for (int i = nStart; i < nEnd; i++)
{
rgShape.Add(colBottom[0].shape(i));
}
Blob <T> blobScale = new Blob <T>(m_cuda, m_log, rgShape);
blobScale.Name = "scale";
FillerParameter fp = p.filler;
// Default to unit (1) filler for identity operation.
if (fp == null)
{
fp = new FillerParameter("constant", 1.0);
}
Filler <T> filler = Filler <T> .Create(m_cuda, m_log, fp);
filler.Fill(blobScale);
m_colBlobs.Add(blobScale);
}
if (p.bias_term)
{
LayerParameter pb = new LayerParameter(LayerParameter.LayerType.BIAS);
pb.bias_param.axis = p.axis;
pb.bias_param.num_axes = (colBottom.Count > 1) ? colBottom[1].num_axes : p.num_axes;
pb.bias_param.filler = p.bias_filler;
m_colBiasBottomVec = new BlobCollection <T>();
m_colBiasBottomVec.Add(colBottom[0]);
m_biasLayer = new BiasLayer <T>(m_cuda, m_log, pb);
m_biasLayer.Setup(m_colBiasBottomVec, colTop);
m_nBiasParamId = m_colBlobs.Count;
m_colBlobs.Add(m_biasLayer.blobs[0]);
m_rgbBiasPropagateDown = Utility.Create <bool>(1, false);
}
m_rgbParamPropagateDown = new DictionaryMap <bool>(m_colBlobs.Count(), true);
}
/// <summary>
/// Setup the layer.
/// </summary>
/// <param name="colBottom">Specifies the collection of bottom (input) Blobs.</param>
/// <param name="colTop">Specifies the collection of top (output) Blobs.</param>
public override void LayerSetUp(BlobCollection <T> colBottom, BlobCollection <T> colTop)
{
m_log.CHECK_GE(colBottom[0].num_axes, 2, "Number of axes of bottom must be >= 2");
PReLUParameter p = m_param.prelu_param;
int nChannels = colBottom[0].channels;
m_bChannelShared = p.channel_shared;
if (m_colBlobs.Count > 0)
{
m_log.WriteLine("Skipping parameter initialization.");
}
else
{
m_colBlobs = new BlobCollection <T>();
List <int> rgSlopeShape = new List <int>();
if (!m_bChannelShared)
{
rgSlopeShape.Add(nChannels);
}
Blob <T> blobSlope = new Blob <T>(m_cuda, m_log);
blobSlope.Name = m_param.name + " slope";
blobSlope.type = BLOB_TYPE.INTERNAL;
if (!shareParameter(blobSlope, rgSlopeShape))
{
blobSlope.Reshape(rgSlopeShape);
FillerParameter fp = p.filler;
if (fp == null)
{
fp = new FillerParameter("constant", 0.25);
}
Filler <T> filler = Filler <T> .Create(m_cuda, m_log, fp);
filler.Fill(blobSlope);
}
m_colBlobs.Add(blobSlope);
}
if (m_bChannelShared)
{
m_log.CHECK_EQ(m_colBlobs[0].count(), 1, "Negative slope size is inconsistent with prototxt config.");
}
else
{
m_log.CHECK_EQ(m_colBlobs[0].count(), nChannels, "Negative slope size is inconsistent with prototxt config.");
}
// Propagate gradients to the parameters (as directed by backward pass)
m_rgbParamPropagateDown = new DictionaryMap <bool>(m_colBlobs.Count, true);
List <int> rgShape = new List <int>()
{
colBottom[0].count(1)
};
m_blobMultiplier.Reshape(rgShape);
m_blobBackwardBuff.Reshape(rgShape);
m_blobMultiplier.SetData(1.0);
}
/// <summary>
/// Checks the gradient of a single output with respect to particular input
/// blob(s). If check_bottom = i >= 0, check only the ith bottom Blob<T>.
/// If check_bottom == -1, check everything -- all bottom Blobs and all
/// param Blobs. Otherwise (if check_bottom less than -1), check only param Blobs.
/// </summary>
public void CheckGradientSingle(Layer <T> layer, BlobCollection <T> colBottom, BlobCollection <T> colTop, int nCheckBottom, int nTopID, int nTopDataID, bool bElementwise = false)
{
if (bElementwise)
{
m_log.CHECK_EQ(0, layer.blobs.Count(), "Cannot have blobs in the layer checked for element-wise checking.");
m_log.CHECK_LE(0, nTopID, "The top ID '" + nTopID.ToString() + "' must be zero or greater with element-wise checking.");
m_log.CHECK_LE(0, nTopDataID, "The top data ID '" + nTopDataID.ToString() + "' must be zero or greater with element-wise checking.");
int nTopCount = colTop[nTopID].count();
for (int nBlobID = 0; nBlobID < colBottom.Count(); nBlobID++)
{
m_log.CHECK_EQ(nTopCount, colBottom[nBlobID].count(), "The top count and blob counts must be equal for element-wise checking.");
}
}
// First, figure out what blobs we need to check against, and zero init
// parameter blobs.
BlobCollection <T> colBlobsToCheck = new BlobCollection <T>();
List <bool> rgPropagateDown = new List <bool>();
for (int i = 0; i < colBottom.Count; i++)
{
rgPropagateDown.Add((nCheckBottom == -1) ? true : false);
}
for (int i = 0; i < layer.blobs.Count; i++)
{
Blob <T> blob = layer.blobs[i];
blob.SetDiff(0);
colBlobsToCheck.Add(blob);
}
if (nCheckBottom == -1)
{
for (int i = 0; i < colBottom.Count; i++)
{
colBlobsToCheck.Add(colBottom[i]);
}
}
else if (nCheckBottom >= 0)
{
m_log.CHECK_LT(nCheckBottom, colBottom.Count, "The check bottom value '" + nCheckBottom.ToString() + "' must be less than the number of bottom blobs.");
colBlobsToCheck.Add(colBottom[nCheckBottom]);
rgPropagateDown[nCheckBottom] = true;
}
m_log.CHECK_GT(colBlobsToCheck.Count, 0, "No blobs to check!");
// Compute the gradient analytically using Backward.
m_cuda.rng_setseed(m_uiSeed);
// Ignore the loss from the layer (it's just the weighted sum of the losses
// from the top blobs, whose gradients we may want to test individually).
layer.Forward(colBottom, colTop);
// Get additional loss from the objective.
GetObjAndGradient(layer, colTop, nTopID, nTopDataID);
layer.Backward(colTop, rgPropagateDown, colBottom);
// Store computed gradients for all checked blobs
BlobCollection <T> colComputedGradientBlobs = new BlobCollection <T>();
for (int nBlobID = 0; nBlobID < colBlobsToCheck.Count; nBlobID++)
{
Blob <T> current_blob = colBlobsToCheck[nBlobID];
Blob <T> new_blob = new Blob <T>(m_cuda, m_log);
if (current_blob.DiffExists)
{
new_blob.ReshapeLike(current_blob);
m_cuda.copy(current_blob.count(), current_blob.gpu_diff, new_blob.mutable_gpu_data);
}
colComputedGradientBlobs.Add(new_blob);
}
// Compute derivative of top w.r.t. each bottom and parameter input using
// finite differencing.
for (int nBlobID = 0; nBlobID < colBlobsToCheck.Count; nBlobID++)
{
Blob <T> current_blob = colBlobsToCheck[nBlobID];
if (!current_blob.DiffExists)
{
continue;
}
T[] rgdfComputedGradients = colComputedGradientBlobs[nBlobID].update_cpu_data();
double dfData;
for (int nFeatID = 0; nFeatID < current_blob.count(); nFeatID++)
{
if (m_evtCancel.WaitOne(0))
{
throw new Exception("Aborted!");
}
// For an element-wise layer, we only need to do finite differencing to
// compute the derivative of top[nTopID][nTopDataID] w.r.t.
// bottom[nBlobID][i] only for i == nTopDataID. For any otehr
// i != nTopDataID, we know the derivative is 0 by definition, and simply
// check that that's true.
double dfEstimateGradient = 0;
double dfPositiveObjective = 0;
double dfNegativeObjective = 0;
if (!bElementwise || (nFeatID == nTopDataID))
{
// Do finite differencing.
// Compute loss with stepwise added to input.
dfData = (double)Convert.ChangeType(current_blob.GetData(nFeatID), typeof(double));
dfData += m_dfStepsize;
current_blob.SetData(dfData, nFeatID);
m_cuda.rng_setseed(m_uiSeed);
layer.Forward(colBottom, colTop);
dfPositiveObjective = GetObjAndGradient(layer, colTop, nTopID, nTopDataID);
// Compute loss with stepsize subtracted from input.
dfData = (double)Convert.ChangeType(current_blob.GetData(nFeatID), typeof(double));
dfData -= (m_dfStepsize * 2);
current_blob.SetData(dfData, nFeatID);
m_cuda.rng_setseed(m_uiSeed);
layer.Forward(colBottom, colTop);
dfNegativeObjective = GetObjAndGradient(layer, colTop, nTopID, nTopDataID);
// Recover original input value.
dfData = (double)Convert.ChangeType(current_blob.GetData(nFeatID), typeof(double));
dfData += m_dfStepsize;
current_blob.SetData(dfData, nFeatID);
dfEstimateGradient = (dfPositiveObjective - dfNegativeObjective) / m_dfStepsize / 2.0;
}
double dfComputedGradient = (double)Convert.ChangeType(rgdfComputedGradients[nFeatID], typeof(double));
double dfFeature = (double)Convert.ChangeType(current_blob.GetData(nFeatID), typeof(double));
if (m_dfKink - m_dfKinkRange > Math.Abs(dfFeature) ||
Math.Abs(dfFeature) > m_dfKink + m_dfKinkRange)
{
// We check the relative accuracy, but for too small values, we threshold
// the scale factor by 1.
double dfScale = Math.Max(Math.Max(Math.Abs(dfComputedGradient), Math.Abs(dfEstimateGradient)), 1.0);
m_log.EXPECT_NEAR(dfComputedGradient, dfEstimateGradient, m_dfThreshold * dfScale, "DEBUG: (nTopID, nTopDataID, nBlobID, nFeatID)=" + nTopID.ToString() + ", " + nTopDataID.ToString() + ", " + nBlobID.ToString() + ", " + nFeatID.ToString() + "; feat = " + dfFeature.ToString() + "; objective+ = " + dfPositiveObjective.ToString() + "; objective- = " + dfNegativeObjective.ToString());
}
}
}
}
