public void TestReadSpectralIndices()
{
var testSpectra = PathHelper.ResolveAssetPath("20160725_203006_continuous1__Towsey.Acoustic.ACI.csv");
var dir = PathHelper.TestResources.ToDirectoryEntry();
var matrix = IndexMatrices.ReadSpectralIndices(
dir,
"20160725_203006_continuous1",
"Towsey.Acoustic",
new[] { "ACI" })
.Single()
.Value;
Assert.AreEqual(256, matrix.GetLength(0));
Assert.AreEqual(30, matrix.GetLength(1));
Assert.AreEqual(0.462924678189025, matrix[255, 0]);
Assert.AreEqual(0.42779069684277, matrix[254, 0]);
Assert.AreEqual(0.46412042529103, matrix[255, 1]);
Assert.AreEqual(0.444650614488611, matrix[254, 1]);
var matrix2 = IndexMatrices.ReadSpectrogram(testSpectra.ToFileInfo(), out var binCount);
matrix2 = MatrixTools.MatrixRotate90Anticlockwise(matrix2);
var actualEnumerator = matrix2.GetEnumerator();
foreach (var expected in matrix)
{
actualEnumerator.MoveNext();
Assert.AreEqual(expected, (double)actualEnumerator.Current, 1E-14, $"delta: {expected - (double)actualEnumerator.Current}");
}
}
public void TestReadSpectrogram()
{
var testSpectra = PathHelper.ResolveAssetPath("20160725_203006_continuous1__Towsey.Acoustic.ACI.csv");
var matrix = IndexMatrices.ReadSpectrogram(testSpectra.ToFileInfo(), out var binCount);
Assert.AreEqual(30, matrix.GetLength(0));
Assert.AreEqual(256, matrix.GetLength(1));
Assert.AreEqual(256, binCount);
Assert.AreEqual(0.462924678189025, matrix[0, 0]);
Assert.AreEqual(0.42779069684277, matrix[0, 1]);
Assert.AreEqual(0.46412042529103, matrix[1, 0]);
Assert.AreEqual(0.444650614488611, matrix[1, 1]);
}
public void TestWriteReadSpectrogram()
{
var random = TestHelpers.Random.GetRandom();
var testSpectra = random.NextMatrix(100, 50);
var testFile = this.outputDirectory.CombineFile("test.matrix.csv");
Csv.WriteMatrixToCsv(testFile, testSpectra);
var matrix = IndexMatrices.ReadSpectrogram(testFile, out var binCount);
Assert.AreEqual(100, matrix.GetLength(0));
Assert.AreEqual(50, matrix.GetLength(1));
Assert.AreEqual(50, binCount);
var actualEnumerator = matrix.GetEnumerator();
foreach (var expected in testSpectra)
{
actualEnumerator.MoveNext();
Assert.AreEqual(expected, (double)actualEnumerator.Current, 1E-14, $"delta: {expected - (double)actualEnumerator.Current}");
}
}
} //Execute()
public static Output GetInstanceRepresentations(Arguments arguments)
{
LoggedConsole.WriteLine("1. Read in all Instances and do feature extraction");
//################################### FEATURE WEIGHTS
//TRY DIFFERENT WEIGHTINGS assuming following "SPT,RHZ,RVT,RPS,RNG";
bool doDeltaFeatures = false;
double[] weights = { 1.0, 1.0, 0.8, 0.7, 0.7 };
double[] deltaWeights = { 1.0, 1.0, 0.8, 0.7, 0.7, 0.5, 0.4, 0.4, 0.2, 0.2 };
if (doDeltaFeatures)
{
weights = deltaWeights;
}
//MAX-POOLING for SPECTRAL REDUCTION
// frequency bins used to reduce dimensionality of the 256 spectral values.
int startBin = 8;
int maxOf2Bin = 117;
int maxOf3Bin = 160;
int endBin = 200;
double[] testArray = new double[256];
for (int i = 0; i < testArray.Length; i++)
{
testArray[i] = i;
}
double[] reducedArray = MaxPoolingLimited(testArray, startBin, maxOf2Bin, maxOf3Bin, endBin);
int reducedSpectralLength = reducedArray.Length;
LoggedConsole.WriteLine(" Reduced spectral length = " + reducedSpectralLength);
int instanceCount = arguments.InstanceCount;
int speciesCount = arguments.SpeciesCount;
// READ IN THE SPECIES LABELS FILE AND SET UP THE DATA
string[] fileID = new string[instanceCount];
int[] speciesID = new int[speciesCount];
ReadGlotinsSpeciesLabelFile(arguments.SpeciesLabelsFile, instanceCount, out fileID, out speciesID);
// INIT array of species counts
int[] instanceNumbersPerSpecies = new int[speciesCount];
// INIT array of frame counts
int[] frameNumbersPerInstance = new int[instanceCount];
// initialise species description matrix
var keyArray = FEATURE_KEYS.Split(',');
int totalFeatureCount = keyArray.Length * reducedArray.Length;
Console.WriteLine(" Total Feature Count = " + totalFeatureCount);
if (doDeltaFeatures)
{
totalFeatureCount *= 2;
LoggedConsole.WriteLine(" Total Delta Feature Count = " + totalFeatureCount);
}
// one matrix row per species
double[,] instanceFeatureMatrix = new double[instanceCount, totalFeatureCount];
// loop through all all instances
for (int j = 0; j < instanceCount; j++)
{
LoggedConsole.Write(".");
int frameCount = 0;
// get the spectral index files
int speciesLabel = speciesID[j];
// dictionary to store feature spectra for instance.
var aggreDictionary = new Dictionary <string, double[]>();
// dictionary to store delta spectra for instance.
var deltaDictionary = new Dictionary <string, double[]>();
foreach (string key in keyArray)
{
string name = string.Format("{0}_Species{1:d2}.{2}.csv", fileID[j], speciesLabel, key);
FileInfo file = new FileInfo(Path.Combine(arguments.InputDataDirectory.FullName, name));
if (file.Exists)
{
int binCount;
double[,] matrix = IndexMatrices.ReadSpectrogram(file, out binCount);
// create or get the array of spectral values.
double[] aggregateArray = new double[reducedSpectralLength];
double[] deltaArray = new double[reducedSpectralLength];
double[] ipVector = MatrixTools.GetRow(matrix, 0);
ipVector = DataTools.SubtractValueAndTruncateToZero(ipVector, arguments.BgnThreshold);
reducedArray = MaxPoolingLimited(ipVector, startBin, maxOf2Bin, maxOf3Bin, endBin);
double[] previousArray = reducedArray;
// transfer spectral values to array.
int rowCount = matrix.GetLength(0);
//rowCount = (int)Math.Round(rowCount * 0.99); // ###################### USE ONLY 99% of instance
//if (rowCount > 1200) rowCount = 1200;
for (int r = 1; r < rowCount; r++)
{
ipVector = MatrixTools.GetRow(matrix, r);
ipVector = DataTools.SubtractValueAndTruncateToZero(ipVector, arguments.BgnThreshold);
reducedArray = MaxPoolingLimited(ipVector, startBin, maxOf2Bin, maxOf3Bin, endBin);
for (int c = 0; c < reducedSpectralLength; c++)
{
aggregateArray[c] += reducedArray[c];
// Calculate the DELTA values TWO OPTIONS ##################################################
double delta = Math.Abs(reducedArray[c] - previousArray[c]);
//double delta = reducedArray[c] - previousArray[c];
//if (delta < 0.0) delta = 0.0;
//double delta = previousArray[c]; //previous array - i.e. do not calculate delta
deltaArray[c] += delta;
}
previousArray = reducedArray;
}
aggreDictionary[key] = aggregateArray;
deltaDictionary[key] = deltaArray;
frameCount = rowCount;
} //if (file.Exists)
} //foreach (string key in keyArray)
instanceNumbersPerSpecies[speciesLabel - 1]++;
frameNumbersPerInstance[j] += frameCount;
// create the matrix of instance descriptions which consists of concatenated vectors
// j = index of instance ID = row number
int featureID = 0;
foreach (string key in keyArray)
{
int featureOffset = featureID * reducedSpectralLength;
for (int c = 0; c < reducedSpectralLength; c++)
{
// TWO OPTIONS: SUM OR AVERAGE ######################################
//instanceFeatureMatrix[j, featureOffset + c] = dictionary[key][c];
instanceFeatureMatrix[j, featureOffset + c] = aggreDictionary[key][c] / frameCount;
}
featureID++;
}
if (doDeltaFeatures)
{
foreach (string key in keyArray)
{
int featureOffset = featureID * reducedSpectralLength;
for (int c = 0; c < reducedSpectralLength; c++)
{
// TWO OPTIONS: SUM OR AVERAGE ######################################
//instanceFeatureMatrix[j, featureOffset + c] = dictionary[key][c];
instanceFeatureMatrix[j, featureOffset + c] = deltaDictionary[key][c] / frameCount;
}
featureID++;
}
} // if doDeltaFeatures
} // end for loop j over all instances
LoggedConsole.WriteLine("Done!");
LoggedConsole.WriteLine("\nSum of species number array = " + instanceNumbersPerSpecies.Sum());
LoggedConsole.WriteLine("Sum of frame number array = " + frameNumbersPerInstance.Sum());
bool addLineNumbers = true;
string countsArrayOutputFilePath = Path.Combine(arguments.OutputDirectory.FullName, "BirdClef50_training_Counts.txt");
FileTools.WriteArray2File(instanceNumbersPerSpecies, addLineNumbers, countsArrayOutputFilePath);
// Initialise output data arrays
Output output = new Output();
output.FileID = fileID;
output.SpeciesID = speciesID;
output.InstanceNumbersPerSpecies = instanceNumbersPerSpecies;
output.ReducedSpectralLength = reducedSpectralLength;
// INIT array of frame counts
output.FrameNumbersPerInstance = frameNumbersPerInstance;
// matrix: each row= one instance; each column = one feature
output.InstanceFeatureMatrix = instanceFeatureMatrix;
output.Weights = weights;
return(output);
} // GetInstanceRepresentations()