348 lines
11 KiB
C
348 lines
11 KiB
C
|
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
|
||
|
|
//
|
||
|
|
// Copyright (c) 2001 Microsoft Corporation. All rights reserved.
|
||
|
|
//
|
||
|
|
// Module:
|
||
|
|
// volcano/inc/vtune.h
|
||
|
|
//
|
||
|
|
// Description:
|
||
|
|
// Volcano tuning parameters
|
||
|
|
//
|
||
|
|
// Author:
|
||
|
|
// hrowley
|
||
|
|
//
|
||
|
|
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
|
||
|
|
|
||
|
|
#pragma once
|
||
|
|
|
||
|
|
#include <wtypes.h>
|
||
|
|
#include "common.h"
|
||
|
|
|
||
|
|
// These constants are used to configure which recognizer is used at
|
||
|
|
// which stroke counts. They are also used as indices into a lookup
|
||
|
|
// table for the weight to give to the score from each recognizer.
|
||
|
|
// Configuration for the recognizer
|
||
|
|
#define VOLCANO_CONFIG_NONE -1
|
||
|
|
#define VOLCANO_CONFIG_OTTER 0
|
||
|
|
#define VOLCANO_CONFIG_ZILLA 1
|
||
|
|
#define VOLCANO_CONFIG_HOUND 2
|
||
|
|
|
||
|
|
// How many recognizers are defined above.
|
||
|
|
#define VOLCANO_CONFIG_NUM_CORE_RECOGNIZERS 3
|
||
|
|
|
||
|
|
// The maximum stroke count which needs to be configured
|
||
|
|
#define VOLCANO_CONFIG_MAX_STROKE_COUNT 29
|
||
|
|
|
||
|
|
// Recognizer configuration
|
||
|
|
typedef struct tagVOLCANO_CONFIG
|
||
|
|
{
|
||
|
|
// Which recognizer to use fo reach number of strokes
|
||
|
|
int iRecognizers[VOLCANO_CONFIG_MAX_STROKE_COUNT + 1];
|
||
|
|
} VOLCANO_CONFIG;
|
||
|
|
|
||
|
|
// These values are used as indices into the array of
|
||
|
|
// weights for scores from different recognizer components.
|
||
|
|
|
||
|
|
// The first three are global weights for all recognizer modes
|
||
|
|
// The following two don't actually get tuned because there isn't enough data.
|
||
|
|
#define VTUNE_ADHOC_CIRCLE (0)
|
||
|
|
#define VTUNE_ADHOC_IJ (VTUNE_ADHOC_CIRCLE + 1)
|
||
|
|
#define VTUNE_UNIGRAM (VTUNE_ADHOC_IJ + 1)
|
||
|
|
|
||
|
|
// These parameters are used only in character mode
|
||
|
|
#define VTUNE_CHAR_SHAPE_BOX_UNIGRAM (VTUNE_UNIGRAM + 1)
|
||
|
|
#define VTUNE_CHAR_CRANE (VTUNE_CHAR_SHAPE_BOX_UNIGRAM + 1)
|
||
|
|
#define VTUNE_CHAR_CORE (VTUNE_CHAR_CRANE + 1)
|
||
|
|
|
||
|
|
// These are used in string mode
|
||
|
|
#define VTUNE_STRING_SHAPE_BOX_UNIGRAM (VTUNE_CHAR_CORE + VOLCANO_CONFIG_NUM_CORE_RECOGNIZERS)
|
||
|
|
#define VTUNE_STRING_CRANE (VTUNE_STRING_SHAPE_BOX_UNIGRAM + 1)
|
||
|
|
#define VTUNE_STRING_CORE (VTUNE_STRING_CRANE + 1)
|
||
|
|
#define VTUNE_STRING_SHAPE_BOX_BIGRAM (VTUNE_STRING_CORE + VOLCANO_CONFIG_NUM_CORE_RECOGNIZERS)
|
||
|
|
#define VTUNE_STRING_SMOOTHING_UNIGRAM (VTUNE_STRING_SHAPE_BOX_BIGRAM + 1)
|
||
|
|
#define VTUNE_STRING_BIGRAM (VTUNE_STRING_SMOOTHING_UNIGRAM + 1)
|
||
|
|
#define VTUNE_STRING_CLASS_BIGRAM (VTUNE_STRING_BIGRAM + 1)
|
||
|
|
|
||
|
|
// These are used in free input mode
|
||
|
|
#define VTUNE_FREE_PROB (VTUNE_STRING_CLASS_BIGRAM + 1)
|
||
|
|
#define VTUNE_FREE_SMOOTHING_UNIGRAM (VTUNE_FREE_PROB + 1)
|
||
|
|
#define VTUNE_FREE_BIGRAM (VTUNE_FREE_SMOOTHING_UNIGRAM + 1)
|
||
|
|
#define VTUNE_FREE_CLASS_BIGRAM (VTUNE_FREE_BIGRAM + 1)
|
||
|
|
#define VTUNE_FREE_SHAPE_UNIGRAM (VTUNE_FREE_CLASS_BIGRAM + 1)
|
||
|
|
#define VTUNE_FREE_SHAPE_BIGRAM (VTUNE_FREE_SHAPE_UNIGRAM + 1)
|
||
|
|
#define VTUNE_FREE_SEG_UNIGRAM (VTUNE_FREE_SHAPE_BIGRAM + 1)
|
||
|
|
#define VTUNE_FREE_SEG_BIGRAM (VTUNE_FREE_SEG_UNIGRAM + 1)
|
||
|
|
|
||
|
|
// Total number of weights
|
||
|
|
#define VTUNE_NUM_WEIGHTS (VTUNE_FREE_SEG_BIGRAM + 1)
|
||
|
|
|
||
|
|
// Hold the weights for various recognizer components.
|
||
|
|
// It is also used to hold the individual scores from each component when doing
|
||
|
|
// the tuning, so as to keep the weights and scores in one-to-one correpsondence.
|
||
|
|
typedef struct VOLCANO_WEIGHTS
|
||
|
|
{
|
||
|
|
FLOAT afl[VTUNE_NUM_WEIGHTS];
|
||
|
|
} VOLCANO_WEIGHTS;
|
||
|
|
|
||
|
|
// An array of names of the weights, for the tuning program
|
||
|
|
extern wchar_t *g_wszVTuneWeightNames[VTUNE_NUM_WEIGHTS];
|
||
|
|
|
||
|
|
// Magic key the identifies the tuning database files
|
||
|
|
#define VTUNE_FILE_TYPE 0x19980808
|
||
|
|
|
||
|
|
// Version information for file.
|
||
|
|
#define VTUNE_MIN_FILE_VERSION 0 // First version of code that can read this file
|
||
|
|
#define VTUNE_OLD_FILE_VERSION 0 // Oldest file version this code can read.
|
||
|
|
#define VTUNE_CUR_FILE_VERSION 0 // Current version of code.
|
||
|
|
|
||
|
|
// In addition to holding the weights, this holds other parameters which are
|
||
|
|
// not tuned by the normal linear tuning algorithm, because they have a
|
||
|
|
// non-linear relationship with the scores.
|
||
|
|
typedef struct VOLCANO_PARAMS
|
||
|
|
{
|
||
|
|
DWORD dwFileType; // This should always be set to VTUNE_FILE_TYPE.
|
||
|
|
INT iFileVer; // Version of code that wrote the file.
|
||
|
|
INT iMinCodeVer; // Earliest version of code that can read this file
|
||
|
|
|
||
|
|
VOLCANO_WEIGHTS weights; // Weights for components
|
||
|
|
FLOAT flZillaGeo; // Zilla geometrics weight (untuned for now)
|
||
|
|
FLOAT flStringHwxWeight; // Weight of hwx scores for IFELang3 in string mode
|
||
|
|
FLOAT flStringHwxThreshold; // Threshold for hwx scores for IFELang3 in string mode
|
||
|
|
FLOAT flFreeHwxWeight; // Weight of hwx scores for IFELang3 in free mode
|
||
|
|
FLOAT flFreeHwxThreshold; // Threshold for hwx scores for IFELang3 in free mode
|
||
|
|
} VOLCANO_PARAMS;
|
||
|
|
|
||
|
|
// This structure holds the pointer to the loaded tuning database
|
||
|
|
// as well as information for unloading the database later.
|
||
|
|
typedef struct VOLCANO_PARAMS_INFO
|
||
|
|
{
|
||
|
|
VOLCANO_PARAMS *pTune;
|
||
|
|
LOAD_INFO info;
|
||
|
|
} VOLCANO_PARAMS_INFO;
|
||
|
|
|
||
|
|
// Functions for loading and unloading the database
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneLoadFile
|
||
|
|
//
|
||
|
|
// Given a parameter information structure and a path,
|
||
|
|
// map the database from a file called vtune.bin in that
|
||
|
|
// directory and fill in the info structure.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pInfo: [out] Pointer to the parameter information structure to fill in.
|
||
|
|
// wszPath: [in] Name of directory to map vtune.bin from
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// TRUE on success, FALSE on failure.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
BOOL VTuneLoadFile(VOLCANO_PARAMS_INFO *pInfo, wchar_t *wszPath);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneUnloadFile
|
||
|
|
//
|
||
|
|
// Given a parameter information structure, close the mapping
|
||
|
|
// from the file that holds the parameters.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pInfo: [in] Pointer to the parameter information structure to fill in.
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// TRUE on success, FALSE on failure.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
BOOL VTuneUnloadFile(VOLCANO_PARAMS_INFO *pInfo);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneLoadRes
|
||
|
|
//
|
||
|
|
// Map a resource as the tuning parameter database
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pInfo: [out] Pointer to the database structure to fill in
|
||
|
|
// hInst: [in] DLL to locate the resource in
|
||
|
|
// nResID: [in] Resource ID
|
||
|
|
// nType: [in] Resource type
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// TRUE if the mapping succeeds, FALSE if the mapping fails.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
BOOL VTuneLoadRes(VOLCANO_PARAMS_INFO *pInfo, HINSTANCE hInst, int nResID, int nType);
|
||
|
|
|
||
|
|
// Functions used at runtime
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneInit
|
||
|
|
//
|
||
|
|
// Initialize the parameter database to a reasonable set of defaults
|
||
|
|
// based on the previous volcano parameters.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pTune: [out] Pointer to a parameter database to be initialized
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// None.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
void VTuneInit(VOLCANO_PARAMS *pTune);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneWriteFile
|
||
|
|
//
|
||
|
|
// Given a set of parameters and a file name, write out the database.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pTune: [in] The parameters to write out
|
||
|
|
// wszFileName: [in] The file name to write to
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// TRUE on success, FALSE on failure.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
BOOL VTuneWriteFile(VOLCANO_PARAMS *pTune, wchar_t *wszFileName);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneZeroWeights
|
||
|
|
//
|
||
|
|
// Zero out an array of weights on scores
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pWeights: [out] Pointer to a weights array
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// None.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
void VTuneZeroWeights(VOLCANO_WEIGHTS *pWeights);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneComputeScore
|
||
|
|
//
|
||
|
|
// Compute the weighted sum of the scores and return the result
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pWeights: [in] Pointer to a weights array
|
||
|
|
// pScores: [in] Pointer to a scores array
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// Weighted sum of the scores.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
float VTuneComputeScore(VOLCANO_WEIGHTS *pWeights, VOLCANO_WEIGHTS *pScores);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneComputeScoreNoLM
|
||
|
|
//
|
||
|
|
// Compute the weighted sum of the scores and return the result.
|
||
|
|
// Unlike VTuneComputeScore, this version does not add in the
|
||
|
|
// components of the score related to the language model.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pWeights: [in] Pointer to a weights array
|
||
|
|
// pScores: [in] Pointer to a scores array
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// Weighted sum of the scores.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
float VTuneComputeScoreNoLM(VOLCANO_WEIGHTS *pWeights, VOLCANO_WEIGHTS *pScores);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneAddScores
|
||
|
|
//
|
||
|
|
// Add an array of scores to another array of scores
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pDest: [in/out] Array of scores where the result is stored.
|
||
|
|
// pSrc: [in] Array of scores to add to pDest.
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// None.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
void VTuneAddScores(VOLCANO_WEIGHTS *pDest, VOLCANO_WEIGHTS *pSrc);
|
||
|
|
|
||
|
|
// Functions used at train time
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneLoadFileFromName
|
||
|
|
//
|
||
|
|
// Given a pointer to a parameter structure and a file name, read
|
||
|
|
// the parameter database in.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pTune: [out] Pointer to parameter structure to fill in
|
||
|
|
// wszFileName: [in] File to read from
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// TRUE on success, FALSE on failure.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
BOOL VTuneLoadFileFromName(VOLCANO_PARAMS *pTune, wchar_t *wszFileName);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneCheckFileVersion
|
||
|
|
//
|
||
|
|
// Check the file header and version information in a tuning database
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pTune: [in] Tuning database to check
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// TRUE if file version is okay, FALSE otherwise
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
BOOL VTuneCheckFileVersion(VOLCANO_PARAMS *pTune);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneCompressTuningRecord
|
||
|
|
//
|
||
|
|
// Given an array of scores from the various recognizer components,
|
||
|
|
// write it out to a file in a compact form. The compaction process
|
||
|
|
// makes two assumptions, first that there are less than 32 components,
|
||
|
|
// and second that many of the component scores will be zero. The compact
|
||
|
|
// form consists of a DWORD which is a bitmask of which components
|
||
|
|
// have non-zero stores, followed by FLOATs giving those scores.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// f: [in] File to write tuning information to
|
||
|
|
// pTune: [in] Array of component scores to write out
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// TRUE on success, FALSE on write failure.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
BOOL VTuneCompressTuningRecord(FILE *f, VOLCANO_WEIGHTS *pTune);
|
||
|
|
|
||
|
|
///////////////////////////////////////
|
||
|
|
//
|
||
|
|
// VTuneDecompressTuningRecord
|
||
|
|
//
|
||
|
|
// Given a compacted array of scores as produced by the VTuneCompressTuningRecord,
|
||
|
|
// unpack it into a flat array for use by the tuning programs.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pTune: [out] Pointer to score array to fill in
|
||
|
|
// pBuffer: [in] Pointer to the compacted record
|
||
|
|
//
|
||
|
|
// Return values:
|
||
|
|
// Pointer to the next tuning record.
|
||
|
|
//
|
||
|
|
//////////////////////////////////////
|
||
|
|
DWORD *VTuneDecompressTuningRecord(VOLCANO_WEIGHTS *pTune, DWORD *pBuffer);
|
||
|
|
|