stefan
/
NLMSvariants
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

complete update

This commit is contained in:
gurkenhabicht 2018-05-19 19:04:50 +02:00
parent 17c1c6c1e6
commit 07d6db93dc
4 changed files with 997 additions and 851 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

549
src/cpp_implementation/NLMSvariants.cpp
View File

@ -1,133 +1,185 @@
//
//
// NLMSvariants.c
//
// Created by FBRDNLMS on 26.04.18.
//
/*
===========================================================================
Created by Stefan Friese on 26.04.2018
===========================================================================
*/
//
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <float.h> // DBL_MAX
//#include <float.h> // DBL_MAX
#include "nlms_types.h" // added types
#define NUMBER_OF_SAMPLES 500
#define WINDOWSIZE 5
#define learnrate 0.8
#define RGB_COLOR 255
#if defined(_MSC_VER)
#include <BaseTsd.h>
typedef SSIZE_T ssize_t;
#endif
enum fileSuffix_t { // used in conjunction with mkFileName()
PURE_WEIGHTS,
USED_WEIGHTS,
DIRECT_PREDECESSOR,
RESULTS,
LOCAL_MEAN,
TEST_VALUES,
DIFFERENTIAL_PREDECESSOR
typedef struct {
double *weights;
unsigned windowSize;
unsigned samplesCount;
double learnrate;
} mldata_t;
enum fileHeader{
LOCAL_MEAN_HEADER,
DIRECT_PREDECESSOR_HEADER,
DIFFERENTIAL_PREDECESSOR_HEADER
};
double xSamples[NUMBER_OF_SAMPLES] = { 0.0 };
double *xSamples;
mldata_t *mlData = NULL; // Machine learning
point_t *points = NULL; // Graphing
/* *svg graph building* */
typedef struct {
double xVal[7];
double yVal[7];
}point_t;
point_t points[NUMBER_OF_SAMPLES]; // [0] = xActual, [1]=xpredicted from localMean, [2]=xpredicted from directPredecessor, [3] = xpredicted from differentialpredecessor, [4] = xError from localMean, [5] xError from directPredecessor, [6] xError from differentialPredecessor
/* *ppm read, copy, write* */
typedef struct {
unsigned char red, green, blue;
}colorChannel_t;
typedef struct {
int x, y;
colorChannel_t *data;
}imagePixel_t;
static imagePixel_t * rdPPM(char *fileName); // read PPM file format
void mkPpmFile(char *fileName, imagePixel_t *image); // writes PPM file
int ppmColorChannel(FILE* fp, imagePixel_t *image); // writes colorChannel from PPM file to log file
void colorSamples(FILE* fp); // stores color channel values in xSamples[]
/* *graph building* */
static imagePixel_t * rdPPM(char *fileName); // Read PPM file format
void mkPpmFile(char *fileName, imagePixel_t *image); // Writes PPM file
int ppmColorChannel(FILE* fp, imagePixel_t *image, // Writes colorChannel from PPM file to log file
char *colorChannel, mldata_t *mlData);
void colorSamples(FILE* fp, mldata_t *mlData); // Stores color channel values in xSamples
/* *file handling* */
char * mkFileName(char* buffer, size_t max_len, int suffixId);
char * mkFileName ( char* buffer,
size_t max_len, int suffixId );
char *fileSuffix ( int id );
void myLogger(FILE* fp, point_t points[]);
void mkSvgGraph(point_t points[]);
//void weightsLogger(double *weights, int var);
char *fileHeader ( int id ); // Header inside the logfiles
//void myLogger ( FILE* fp, point_t points[] );
void bufferLogger(char *buffer, point_t points[]); // Writes points to graph template
void mkSvgGraph ( point_t points[] ); // Parses graph template and calls bufferLogger()
void weightsLogger ( double *weights, int suffix ); // Writes updated weights to a file
/* *rand seed* */
double r2(void);
double r2 ( void ); // Random val between 0 and 1
double rndm ( void );
/* *args parser* */
void usage ( void ); // Help text called by args parser
/* *math* */
mldata_t * init_mldata_t(unsigned windowSize, unsigned samplesCount, double learnrate);
double sum_array(double x[], int length);
void directPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]);
void localMean(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]);
void differentialPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]);
//void differentialPredecessor(double *weights);
double *popNAN(double *xError); //return new array without NAN values
double windowXMean(int _arraylength, int xCount);
void localMean ( mldata_t *mlData,point_t points[] ); // First,
void directPredecessor ( mldata_t *mlData, point_t points[] ); // Second,
void differentialPredecessor ( mldata_t *mlData, point_t points[] ); // Third filter implementation
double *popNAN(double *xError); // Returns array without NAN values, if any exist
double windowXMean(int _arraylength, int xCount); // Returns mean value of given window
//int main(int argc, char **argv) {
int main(void) {
double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]; // = { { 0.0 }, {0.0} };
// double local_weights[WINDOWSIZE][NUMBER_OF_SAMPLES];
char fileName[50];
int i, k, xLength;
int main( int argc, char **argv ) {
char *colorChannel = (char *) malloc(sizeof(char)* 32);
char *inputfile = (char *)malloc(sizeof(char) * 32);
unsigned int *seed = NULL;
unsigned k, xLength;
unsigned int windowSize = 5;
unsigned int samplesCount = 501;
char *stdcolor = "green";
colorChannel = stdcolor;
unsigned int uint_buffer[1];
double learnrate = 0.8;
while( (argc > 1) && (argv[1][0] == '-') ) { // Parses parameters from stdin
switch( argv[1][1] ) {
case 'i':
inputfile = &argv[1][3];
++argv;
--argc;
break;
case 'w':
sscanf(&argv[1][3], "%u", &windowSize);
++argv;
--argc;
break;
case 'c':
colorChannel = &argv[1][3];
++argv;
--argc;
break;
case 's':
sscanf(&argv[1][3], "%u", uint_buffer);
seed = &uint_buffer[0];
++argv;
--argc;
break;
case 'n':
sscanf(&argv[1][3], "%u", &samplesCount);
++argv;
--argc;
break;
case'h':
printf("Program name: %s\n", argv[0]);
usage();
break;
case 'l':
sscanf(&argv[1][3], "%lf", &learnrate);
++argv;
--argc;
break;
default:
printf("Wrong Arguments: %s\n", argv[1]);
usage();
}
++argv;
--argc;
}
init_mldata_t(windowSize, samplesCount, learnrate);
xSamples = (double *) malloc ( sizeof(double) * mlData->samplesCount );
points = (point_t *) malloc ( sizeof(point_t) * mlData->samplesCount);
imagePixel_t *image;
char fileName[50];
image = rdPPM("cow.ppm");
image = rdPPM(inputfile);
mkFileName(fileName, sizeof(fileName), TEST_VALUES);
FILE* fp5 = fopen(fileName, "w");
xLength = ppmColorChannel(fp5, image);
xLength = ppmColorChannel(fp5, image, colorChannel, mlData); // Returns length of ppm input values
printf("%d\n", xLength);
FILE* fp6 = fopen(fileName, "r");
colorSamples(fp6);
colorSamples(fp6, mlData);
if ( (seed != NULL) ){
srand( *seed ); // Seed for random number generating
printf("srand is reproducable : %u", seed);
} else {
srand( (unsigned int)time(NULL) );
for (i = 0; i < NUMBER_OF_SAMPLES; i++) {
for (int k = 0; k < WINDOWSIZE; k++) {
weights[k][i] = rndm(); // Init weights
printf("srand from time\n"); // Default seed is time(NULL)
}
// for (i = 0; i < NUMBER_OF_SAMPLES; i++) {
for (k = 0; k < mlData->windowSize; k++) {
mlData->weights[k] = rndm(); // Init random weights
printf("%lf\n", mlData->weights[k]);
}
mkFileName(fileName, sizeof(fileName), PURE_WEIGHTS);
// save plain test_array before math magic happens
FILE *fp0 = fopen(fileName, "w");
for (i = 0; i < NUMBER_OF_SAMPLES; i++) {
for (k = 0; k < WINDOWSIZE; k++) {
fprintf(fp0, "[%d][%d]%lf\n", k, i, weights[k][i]);
}
}
fclose(fp0);
// math magic
localMean(weights);
directPredecessor(weights);
differentialPredecessor(weights);
mkSvgGraph(points);
// save test_array after math magic happened
// memset( fileName, '\0', sizeof(fileName) );
/* mkFileName(fileName, sizeof(fileName), USED_WEIGHTS);
FILE *fp1 = fopen(fileName, "w");
for (i = 0; i < tracking; i++) {
for (int k = 0; k < WINDOWSIZE; k++) {
fprintf(fp1, "[%d][%d] %lf\n", k, i, w[k][i]);
}
// }
mkFileName(fileName, sizeof(fileName), PURE_WEIGHTS);
FILE *fp0 = fopen(fileName, "w");
// for (i = 0; i < NUMBER_OF_SAMPLES; i++) {
for (k = 0; k < mlData->windowSize; k++) {
fprintf(fp0, "[%d]%lf\n", k, mlData->weights[k]); // Save generated weights to to file
}
fclose(fp1);
*/
// }
fclose(fp0);
// math magic
localMean ( mlData, points );
directPredecessor ( mlData, points);
differentialPredecessor( mlData, points );
mkSvgGraph(points);
free(xSamples);
free(points);
printf("\nDONE!\n");
}
/*
======================================================================================================
@ -137,43 +189,37 @@ Variant (1/3), substract local mean.
======================================================================================================
*/
void localMean ( mldata_t *mlData, point_t points[] ) {
// double (*local_weights)[WINDOWSIZE] =(double (*)[WINDOWSIZE]) malloc(sizeof(double) * (WINDOWSIZE+1) * (NUMBER_OF_SAMPLES+1));
//memcpy(local_weights, weights, sizeof(double) * WINDOWSIZE * NUMBER_OF_SAMPLES);
double *localWeights = (double *) malloc ( sizeof(double) * mlData->windowSize + 1);
memcpy ( localWeights, mlData->weights, sizeof(mlData->windowSize) ); // TODO: check size !!!
void localMean(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
//double local_weights[WINDOWSIZE][NUMBER_OF_SAMPLES];
double(*local_weights)[WINDOWSIZE] = (double(*)[WINDOWSIZE])malloc(sizeof(double) * (WINDOWSIZE + 1) * (NUMBER_OF_SAMPLES + 1));
// double *local_weights[WINDOWSIZE];
memcpy(local_weights, weights, sizeof(double) * WINDOWSIZE * NUMBER_OF_SAMPLES);
char fileName[50];
double xError[2048]; // includes e(n)
memset(xError, 0.0, NUMBER_OF_SAMPLES);// initialize xError-array with Zero
int xCount = 0, i; // runtime var;
memset(xError, 0.0, mlData->samplesCount);// initialize xError-array with Zero
unsigned i, xCount = 0; // runtime var
mkFileName(fileName, sizeof(fileName), LOCAL_MEAN);
FILE* fp4 = fopen(fileName, "w");
fprintf(fp4, "\n=====================================LocalMean=====================================\nNo.\txPredicted\txActual\t\txError\n");
fprintf( fp4, fileHeader(LOCAL_MEAN_HEADER) );
double xMean = xSamples[0];
double xSquared = 0.0;
double xPredicted = 0.0;
double xActual = 0.0;
for (xCount = 1; xCount < NUMBER_OF_SAMPLES; xCount++) { // first value will not get predicted
for (xCount = 1; xCount < mlData->samplesCount; xCount++) { // first value will not get predicted
int _arrayLength = (xCount > WINDOWSIZE) ? WINDOWSIZE + 1 : xCount;
unsigned _arrayLength = ( xCount > mlData->windowSize ) ? mlData->windowSize + 1 : xCount;
xMean = (xCount > 0) ? windowXMean(_arrayLength, xCount) : 0;
xPredicted = 0.0;
xActual = xSamples[xCount + 1];
// weightedSum += _x[ xCount-1 ] * w[xCount][0];
xActual = xSamples[xCount];
for (i = 1; i < _arrayLength; i++) { //get predicted value
xPredicted += (local_weights[i][xCount] * (xSamples[xCount - i] - xMean));
xPredicted += (localWeights[i] * (xSamples[xCount - i] - xMean));
}
xPredicted += xMean;
xError[xCount] = xActual - xPredicted;
points[xCount].xVal[1] = xCount;
points[xCount].yVal[1] = xPredicted;
points[xCount].xVal[4] = xCount;
points[xCount].yVal[4] = xError[xCount];
xSquared = 0.0;
for (i = 1; i < _arrayLength; i++) { //get xSquared
xSquared += pow(xSamples[xCount - i] - xMean, 2);
@ -182,14 +228,22 @@ void localMean(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
xSquared = 1.0;
}
for ( i = 1; i < _arrayLength; i++ ) { //update weights
local_weights[i][xCount + 1] = local_weights[i][xCount] + learnrate * xError[xCount] * ((xSamples[xCount - i] - xMean) / xSquared);
localWeights[ i + 1 ] = localWeights[i] + mlData->learnrate * xError[xCount] * ( (xSamples[xCount - i] - xMean) / xSquared );
}
fprintf(fp4, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]);
points[xCount].xVal[1] = xCount;
points[xCount].yVal[1] = xPredicted;
points[xCount].xVal[4] = xCount;
points[xCount].yVal[4] = xError[xCount];
}
double *xErrorPtr = popNAN(xError); // delete NAN values from xError[]
double xErrorLength = *xErrorPtr; // Watch popNAN()!
xErrorPtr[0] = 0.0;
printf("Xerrorl:%lf", xErrorLength);
// printf("Xerrorl:%lf", xErrorLength);
double mean = sum_array(xErrorPtr, xErrorLength) / xErrorLength;
double deviation = 0.0;
@ -205,7 +259,7 @@ void localMean(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
//FILE *fp2 = fopen(fileName, "w");
fprintf(fp4, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
//fclose(fp2);
free(local_weights);
free(localWeights);
fclose(fp4);
//weightsLogger( local_weights, USED_WEIGHTS );
@ -221,61 +275,58 @@ substract direct predecessor
======================================================================================================
*/
void directPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
double(*local_weights)[WINDOWSIZE] = (double(*)[WINDOWSIZE])malloc(sizeof(double) * (WINDOWSIZE + 1) * (NUMBER_OF_SAMPLES + 1));
// double local_weights[WINDOWSIZE][NUMBER_OF_SAMPLES];
memcpy(local_weights, weights, sizeof(double) * WINDOWSIZE * NUMBER_OF_SAMPLES);
void directPredecessor( mldata_t *mlData, point_t points[]) {
double *localWeights = ( double * ) malloc ( sizeof(double) * mlData->windowSize + 1 );
memcpy ( localWeights, mlData->weights, sizeof(mlData->windowSize) );
char fileName[512];
double xError[2048];
int xCount = 0, i;
unsigned xCount = 0, i;
double xActual = 0.0;
double xPredicted = 0.0;
// File handling
mkFileName(fileName, sizeof(fileName), DIRECT_PREDECESSOR);
FILE *fp3 = fopen(fileName, "w");
fprintf(fp3, "\n=====================================DirectPredecessor=====================================\nNo.\txPredicted\txAcutal\t\txError\n");
fprintf( fp3, fileHeader(DIRECT_PREDECESSOR_HEADER) );
mkFileName ( fileName, sizeof(fileName), USED_WEIGHTS);
FILE *fp9 = fopen(fileName, "w");
for (xCount = 1; xCount < NUMBER_OF_SAMPLES; xCount++) { // first value will not get predicted
//double xPartArray[1000]; //includes all values at the size of runtime var
//int _sourceIndex = (xCount > WINDOWSIZE) ? xCount - WINDOWSIZE : xCount;
int _arrayLength = (xCount > WINDOWSIZE) ? WINDOWSIZE + 1 : xCount;
//printf("xCount:%d, length:%d\n", xCount, _arrayLength);
// printf("WINDOWSIZE:%f\n", windowXMean(_arrayLength, xCount));
for (xCount = 1; xCount < mlData->samplesCount; xCount++) { // first value will not get predicted
unsigned _arrayLength = ( xCount > mlData->windowSize ) ? mlData->windowSize + 1 : xCount;
xPredicted = 0.0;
xActual = xSamples[xCount + 1];
// weightedSum += _x[ xCount-1 ] * w[xCount][0];
xActual = xSamples[xCount];
for (i = 1; i < _arrayLength; i++) {
xPredicted += (local_weights[i][xCount] * (xSamples[xCount - 1] - xSamples[xCount - i - 1]));
xPredicted += ( localWeights[i - 1] * (xSamples[xCount - 1] - xSamples[xCount - i - 1]));
}
xPredicted += xSamples[xCount - 1];
xError[xCount] = xActual - xPredicted;
//fprintf(fp3, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]);
points[xCount].xVal[2] = xCount;
points[xCount].yVal[2] = xPredicted;
points[xCount].xVal[5] = xCount;
points[xCount].yVal[5] = xError[xCount];
double xSquared = 0.0;
for (i = 1; i < _arrayLength; i++) {
xSquared += pow(xSamples[xCount - 1] - xSamples[xCount - i - 1], 2); // substract direct predecessor
}
for (i = 1; i < _arrayLength; i++) {
local_weights[i][xCount + 1] = local_weights[i][xCount] + learnrate * xError[xCount] * ((xSamples[xCount - 1] - xSamples[xCount - i - 1]) / xSquared);
}
fprintf(fp3, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]);
localWeights[i + 1] = localWeights[i] + mlData->learnrate * xError[xCount] * ( (xSamples[xCount - 1] - xSamples[xCount - i - 1]) / xSquared);
fprintf( fp9, "%lf\n", localWeights[i] );
}
fprintf(fp3, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]);
points[xCount].xVal[2] = xCount; // Fill point_t array for graph building
points[xCount].yVal[2] = xPredicted;
points[xCount].xVal[5] = xCount;
points[xCount].yVal[5] = xError[xCount];
// weightsLogger( fp, localWeights, USED_WEIGHTS );
}
fclose(fp9);
double *xErrorPtr = popNAN(xError); // delete NAN values from xError[]
//printf("%lf", xErrorPtr[499]);
double xErrorLength = *xErrorPtr; // Watch popNAN()!
xErrorPtr[0] = 0.0;
printf("Xerrorl:%lf", xErrorLength);
//printf("Xerrorl:%lf", xErrorLength);
double mean = sum_array(xErrorPtr, xErrorLength) / xErrorLength;
double deviation = 0.0;
@ -293,12 +344,10 @@ void directPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
fprintf(fp3, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
fclose(fp3);
//fclose(fp2);
free(local_weights);
free(localWeights);
//weightsLogger( local_weights, USED_WEIGHTS );
}
/*
======================================================================================================
@ -309,71 +358,54 @@ differential predecessor.
======================================================================================================
*/
void differentialPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
// double local_weights[WINDOWSIZE][NUMBER_OF_SAMPLES];
double(*local_weights)[WINDOWSIZE] = (double(*)[WINDOWSIZE])malloc(sizeof(double) * (WINDOWSIZE + 1) * (NUMBER_OF_SAMPLES + 1));
memcpy(local_weights, weights, sizeof(double) * WINDOWSIZE * NUMBER_OF_SAMPLES);
void differentialPredecessor ( mldata_t *mlData, point_t points[] ) {
double *localWeights = (double *) malloc ( sizeof(double) * mlData->windowSize + 1 );
memcpy( localWeights, mlData->weights, sizeof(mlData->windowSize) );
char fileName[512];
double xError[2048];
int xCount = 0, i;
unsigned xCount = 0, i;
double xPredicted = 0.0;
double xActual = 0.0;
// File handling
mkFileName(fileName, sizeof(fileName), DIFFERENTIAL_PREDECESSOR);
FILE *fp6 = fopen(fileName, "w");
fprintf(fp6, "\n=====================================DifferentialPredecessor=====================================\nNo.\txPredicted\txAcutal\t\txError\n");
fprintf(fp6, fileHeader(DIFFERENTIAL_PREDECESSOR_HEADER) );
for (xCount = 1; xCount < NUMBER_OF_SAMPLES; xCount++) { // first value will not get predicted
for (xCount = 1; xCount < mlData->samplesCount; xCount++) { // first value will not get predicted
int _arrayLength = (xCount > WINDOWSIZE) ? WINDOWSIZE + 1 : xCount;
unsigned _arrayLength = (xCount > mlData->windowSize) ? mlData->windowSize + 1 : xCount;
xPredicted = 0.0;
xActual = xSamples[xCount + 1];
xActual = xSamples[xCount];
for (i = 1; i < _arrayLength; i++) {
xPredicted += (local_weights[i][xCount] * (xSamples[xCount - i] - xSamples[xCount - i - 1]));
xPredicted += ( localWeights[i - 1] * (xSamples[xCount - i] - xSamples[xCount - i - 1]));
}
xPredicted += xSamples[xCount - 1];
xError[xCount] = xActual - xPredicted;
//fprintf(fp6, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]);
points[xCount].xVal[3] = xCount;
points[xCount].yVal[3] = xPredicted;
points[xCount].xVal[6] = xCount;
points[xCount].yVal[6] = xError[xCount];
double xSquared = 0.0;
for (i = 1; i < _arrayLength; i++) {
xSquared += pow(xSamples[xCount - i] - xSamples[xCount - i - 1], 2); // substract direct predecessor
}
for (i = 1; i < _arrayLength; i++) {
local_weights[i][xCount + 1] = local_weights[i][xCount] + learnrate * xError[xCount] * ((xSamples[xCount - i] - xSamples[xCount - i - 1]) / xSquared);
localWeights[i+1] = localWeights[i] + mlData->learnrate * xError[xCount] * ((xSamples[xCount - i] - xSamples[xCount - i - 1]) / xSquared);
}
fprintf(fp6, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]);
fprintf(fp6, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]); // Write to logfile
points[xCount].xVal[3] = xCount;
points[xCount].yVal[3] = xPredicted;
points[xCount].xVal[6] = xCount;
points[xCount].yVal[6] = xError[xCount];
}
/* int xErrorLength = sizeof(xError) / sizeof(xError[0]);
printf("vor:%d", xErrorLength);
popNAN(xError);
printf("nach:%d", xErrorLength);
xErrorLength = sizeof(xError) / sizeof(xError[0]);
double mean = sum_array(xError, xErrorLength) / xErrorLength;
double deviation = 0.0;
for (i = 0; i < xErrorLength - 1; i++) {
deviation += pow(xError[i] - mean, 2);
}
deviation /= xErrorLength;
//mkSvgGraph(points);
fprintf(fp6, "{%d}.\tLeast Mean Squared{%f}\tMean{%f}\n\n", xCount, deviation, mean);
*/
double *xErrorPtr = popNAN(xError); // delete NAN values from xError[]
//printf("%lf", xErrorPtr[499]);
double xErrorLength = *xErrorPtr; // Watch popNAN()!
xErrorPtr[0] = 0.0;
printf("Xerrorl:%lf", xErrorLength);
// printf("Xerrorl:%lf", xErrorLength);
double mean = sum_array(xErrorPtr, xErrorLength) / xErrorLength;
double deviation = 0.0;
@ -391,12 +423,11 @@ void differentialPredecessor(double weights[WINDOWSIZE][NUMBER_OF_SAMPLES]) {
fprintf(fp6, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
//fclose(fp2);
fclose(fp6);
free(local_weights);
free(localWeights);
//weightsLogger( local_weights, USED_WEIGHTS );
// weightsLogger( localWeights, USED_WEIGHTS );
}
/*
======================================================================================================
@ -407,9 +438,7 @@ into the given buffer. If the total length is longer than max_len,
only max_len characters will be written.
======================================================================================================
*/
char *mkFileName(char* buffer, size_t max_len, int suffixId) {
const char * format_str = "%Y-%m-%d_%H_%M_%S";
size_t date_len;
@ -422,7 +451,6 @@ char *mkFileName(char* buffer, size_t max_len, int suffixId) {
return buffer;
}
/*
======================================================================================================
@ -432,12 +460,34 @@ Contains and returns every suffix for all existing filenames
======================================================================================================
*/
char * fileSuffix ( int id ) {
char * suffix[] = { "_weights_pure.txt", "_weights_used.txt", "_direct_predecessor.txt", "_ergebnisse.txt", "_localMean.txt","_testvalues.txt", "_differential_predecessor.txt" };
char * suffix[] = { "_weights_pure.txt",
"_weights_used.txt",
"_direct_predecessor.txt",
"_ergebnisse.txt",
"_localMean.txt",
"_testvalues.txt",
"_differential_predecessor.txt"
};
return suffix[id];
}
/*
======================================================================================================
fileHeader
Contains and returns header for logfiles
======================================================================================================
*/
char * fileHeader ( int id ) {
char * header[] = { "\n=========================== Local Mean ===========================\nNo.\txPredicted\txAcutal\t\txError\n",
"\n=========================== Direct Predecessor ===========================\nNo.\txPredicted\txAcutal\t\txError\n",
"\n=========================== Differential Predecessor ===========================\nNo.\txPredicted\txAcutal\t\txError\n"
};
return header[id];
}
/*
======================================================================================================
@ -448,13 +498,12 @@ Logs x,y points to svg graph
======================================================================================================
*/
void weightsLogger(double weights[WINDOWSIZE], int val) {
void weightsLogger (double *weights, int val ) {
char fileName[512];
int i;
unsigned i;
mkFileName(fileName, sizeof(fileName), val);
FILE* fp = fopen(fileName, "wa");
for (i = 0; i < WINDOWSIZE; i++) {
for (i = 0; i < mlData->windowSize - 1; i++) {
// for (int k = 0; k < WINDOWSIZE; k++) {
fprintf(fp, "[%d]%lf\n", i, weights[i]);
// }
@ -463,44 +512,48 @@ void weightsLogger(double weights[WINDOWSIZE], int val) {
fclose(fp);
}
/*
======================================================================================================
bufferLogger
formats output of mkSvgGraph -- Please open graphResults.html to see the output--
[0] = xActual,
[1] = xPredicted from localMean,
[2] = xPredicted from directPredecessor,
[3] = xPredicted from differentialpredecessor,
[4] = xError from localMean,
[5] = xError from directPredecessor,
[6] = xError from differentialPredecessor
======================================================================================================
*/
void bufferLogger(char *buffer, point_t points[]) {
int i;
unsigned i;
char _buffer[512] = "";
for (i = 0; i < NUMBER_OF_SAMPLES - 1; i++) { // xActual
for (i = 0; i < mlData->samplesCount - 1; i++) { // xActual
sprintf(_buffer, "L %f %f\n", points[i].xVal[0], points[i].yVal[0]);
strcat(buffer, _buffer);
}
strcat(buffer, "\" fill=\"none\" id=\"svg_1\" stroke=\"black\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
for (i = 0; i < NUMBER_OF_SAMPLES - 1; i++) { // xPredicted from localMean
for (i = 0; i < mlData->samplesCount - 1; i++) { // xPredicted from localMean
sprintf(_buffer, "L %f %f\n", points[i].xVal[1], points[i].yVal[1]);
strcat(buffer, _buffer);
}
strcat(buffer, "\" fill=\"none\" id=\"svg_2\" stroke=\"green\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
for (i = 0; i <= NUMBER_OF_SAMPLES - 1; i++) { //xPreddicted from directPredecessor
for (i = 0; i <= mlData->samplesCount - 1; i++) { //xPreddicted from directPredecessor
sprintf(_buffer, "L %f %f\n", points[i].xVal[2], points[i].yVal[2]);
strcat(buffer, _buffer);
}
strcat(buffer, "\" fill=\"none\" id=\"svg_3\" stroke=\"blue\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
for (i = 0; i < NUMBER_OF_SAMPLES - 1; i++) { //xPredicted from diff Pred
for (i = 0; i < mlData->samplesCount - 1; i++) { //xPredicted from diff Pred
sprintf(_buffer, "L %f %f\n", points[i].xVal[3], points[i].yVal[3]);
strcat(buffer, _buffer);
}
strcat(buffer, "\" fill=\"none\" id=\"svg_4\" stroke=\"red\" stroke-width=\"0.4px\"/>\n");
}
/*
======================================================================================================
@ -510,7 +563,6 @@ Sum of all elements in x within a defined length
======================================================================================================
*/
double sum_array(double x[], int xlength) {
int i = 0;
double sum = 0.0;
@ -523,7 +575,6 @@ double sum_array(double x[], int xlength) {
return sum;
}
/*
======================================================================================================
@ -533,20 +584,19 @@ returns length of new array without NAN values
======================================================================================================
*/
double *popNAN(double *xError) {
int i, counter = 1;
unsigned i, counter = 1;
double tmpLength = 0.0;
double *tmp = NULL;
double *more_tmp = NULL;
for (i = 0; i < NUMBER_OF_SAMPLES; i++) {
for ( i = 0; i < mlData->samplesCount - 1; i++ ) {
counter ++;
more_tmp = (double *) realloc ( tmp, counter*(sizeof(double) ));
if ( !isnan(xError[i]) ) {
tmp = more_tmp;
tmp[counter - 1] = xError[i];
printf("xERROR:%lf\n", tmp[counter - 1]);
//printf("xERROR:%lf\n", tmp[counter - 1]);
tmpLength++;
}
}
@ -560,6 +610,7 @@ double *popNAN(double *xError) {
return tmp;
}
/*
======================================================================================================
@ -569,12 +620,10 @@ returns a random double value between 0 and 1
======================================================================================================
*/
double r2(void) {
return((rand() % 10000) / 10000.0);
}
/*
======================================================================================================
@ -584,13 +633,11 @@ fills a double variable with random value and returns it
======================================================================================================
*/
double rndm(void) {
double rndmval = r2();
return rndmval;
}
/*
======================================================================================================
@ -600,7 +647,6 @@ parses template.svg and writes results in said template
======================================================================================================
*/
void mkSvgGraph(point_t points[]) {
FILE *input = fopen("graphResults_template.html", "r");
FILE *target = fopen("graphResults.html", "w");
@ -625,7 +671,6 @@ void mkSvgGraph(point_t points[]) {
fprintf(target, buffer);
}
/*
======================================================================================================
@ -636,7 +681,6 @@ size of given picture
======================================================================================================
*/
static imagePixel_t *rdPPM(char *fileName) {
char buffer[16];
imagePixel_t *image;
@ -689,7 +733,6 @@ static imagePixel_t *rdPPM(char *fileName) {
return image;
}
/*
======================================================================================================
@ -700,7 +743,6 @@ carbon copy of the source image. Build for debugging
======================================================================================================
*/
void mkPpmFile(char *fileName, imagePixel_t *image) {
FILE* fp = fopen(fileName, "wb");
if (!fp) {
@ -714,7 +756,6 @@ void mkPpmFile(char *fileName, imagePixel_t *image) {
fclose(fp);
}
/*
======================================================================================================
@ -724,37 +765,54 @@ gets one of the rgb color channels and writes them to a file
======================================================================================================
*/
int ppmColorChannel(FILE* fp, imagePixel_t *image) {
int ppmColorChannel(FILE* fp, imagePixel_t *image, char *colorChannel, mldata_t *mlData) {
// int length = (image->x * image->y) / 3;
int i = 0;
unsigned i = 0;
printf("colorChannel in Function: %s", colorChannel);
if (image) {
for (i = 0; i < NUMBER_OF_SAMPLES - 1; i++) {
if (strcmp(colorChannel, "green") == 0){
for (i = 0; i < mlData->samplesCount - 1; i++) {
fprintf(fp, "%d\n", image->data[i].green);
printf("|");
}
} else if (strcmp(colorChannel, "red") == 0){
for (i = 0; i < mlData->samplesCount - 1; i++) {
fprintf(fp, "%d\n", image->data[i].red);
printf(".");
}
} else if (strcmp(colorChannel, "blue") == 0 ) {
for (i = 0; i < mlData->samplesCount - 1; i++ ) {
fprintf(fp, "%d\n", image->data[i].blue);
printf("/");
}
} else {
printf("Colorchannels are red, green and blue. Pick one of them!");
exit(EXIT_FAILURE);
}
}
fclose(fp);
return NUMBER_OF_SAMPLES;
return mlData->samplesCount;
}
/*
======================================================================================================
colorSamples
reads colorChannel values from file and stores them in xSamples as well as points datatype for
reads colorChannel values from file and stores them in xSamples as well as in points datatype for
creating the SVG graph
======================================================================================================
*/
void colorSamples(FILE* fp) {
void colorSamples ( FILE* fp, mldata_t *mlData ) {
int i = 0;
char buffer[NUMBER_OF_SAMPLES];
//char buffer[NUMBER_OF_SAMPLES];
char *buffer = (char *) malloc(sizeof(char) * mlData->samplesCount);
while (!feof(fp)) {
if (fgets(buffer, NUMBER_OF_SAMPLES, fp) != NULL) {
if (fgets(buffer, mlData->samplesCount, fp) != NULL) {
sscanf(buffer, "%lf", &xSamples[i]);
//printf("%lf\n", xSamples[i] );
points[i].yVal[0] = xSamples[i];
@ -765,7 +823,6 @@ void colorSamples(FILE* fp) {
fclose(fp);
}
/*
======================================================================================================
@ -775,7 +832,6 @@ returns mean value of given input, which has a length of WINDOWSIZE
======================================================================================================
*/
double windowXMean(int _arraylength, int xCount) {
double sum = 0.0;
double *ptr;
@ -786,4 +842,45 @@ double windowXMean(int _arraylength, int xCount) {
return sum / (double)_arraylength;
}
/*
======================================================================================================
usage
used in conjunction with the args parser. Returns help section of "-h"
======================================================================================================
*/
void usage ( void ) {
printf("Usage: lms [POSIX style options] -i file ...\n");
printf("POSIX options:\n");
printf("\t-h\t\t\tDisplay this information.\n");
printf("\t-i <filename>\t\tName of inputfile. Must be PPM image.\n");
printf("\t-n <digit>\t\tAmount of input data used.\n");
printf("\t-c <color>\t\tUse this color channel from inputfile.\n");
printf("\t-w <digit>\t\tCount of used weights (windowSize).\n");
printf("\t-l <digit>\t\tLearnrate, 0 < learnrate < 1.\n");
printf("\t-s <digit>\t\tDigit for random seed generator.\n\t\t\t\tSame Digits produce same random values. Default is srand by time.");
printf("\n\n");
printf("lms compares prediction methods of least mean square filters.\nBy default it reads ppm file format and return logfiles as well\nas an svg graphs as an output of said least mean square methods.\n\nExample:\n\tlms -i myimage.ppm -w 3 -c green -s 5\n");
exit(8);
}
/*
======================================================================================================
init_mldata_t
Contains meachine learning data
======================================================================================================
*/
mldata_t * init_mldata_t(unsigned windowSize, unsigned samplesCount, double learnrate) {
mlData = (mldata_t *) malloc( sizeof(mldata_t) );
mlData->windowSize = windowSize;
mlData->samplesCount = samplesCount;
mlData->learnrate = learnrate;
mlData->weights = (double *) malloc ( sizeof(double) * windowSize + 1 );
return mlData;
}

32
src/cpp_implementation/README.md Normal file
View File

@ -0,0 +1,32 @@
## Installation
This is a carbon copy of the ANSI C version. Sole purpose of its existence is to be compiled under Visual Studio.
If you do not use VS, pick the ANSI C version __../src/ansi_c__implementation__.
## Features
This little piece of code compares 3 different implementations of a least mean square filter.
+ local mean
+ direct predecessor
+ differential predecessor
Greyscale PPM files can be used for input at this iteration. Output will be generated as .txt files with predicted value generated by the filter and its error value as well as given actual value from the PPM file. Furthermore there is an output as an svg graph to compare the implementatiosn on a visual level. These graphical results are build from __graphResults_template.html__ which creates the actual output to __graphResults.html__. Open this file to see the results.
You can hide graphs by clicking on its name for better visibility.
Use `$ ./lms -h` for help.
### Usage
There are a bunch of options you can predefine but do not have to. The only parameter needed is __-i__ which is the inputfile.
| Parameter | Description | StdVal |
|----------:|:-----------------------------:|:-------|
| -i | The inputfile, has to be PPM | none |
| -n | Amount of input data used | 500 |
| -w | Size of M (window) | 5 |
| -c | Choose RGB color channel, green has least noise. | green |
| -l | Learnrate of machine learning | 0.8 |
| -s | Seed randomizing weights. Choose for repoducability. | time(NULL)|

39
src/cpp_implementation/graphResults_template.html
View File

@ -2,10 +2,11 @@
<html>
<head>
NLMSvariants | Graphical Output ||
<font id="1" color="blue" onclick="clicksvg(this)">Eingangswert</font> |
<font id="2" color="red" onclick="clicksvg(this)">direkter Vorgaenger</font> |
<font id="3" color="green" onclick="clicksvg(this)">letzter Mittelwert</font>
NLMSvariants | Graphical Output || click font to hide graph
<h2><font face="arial" id="1" color="black" onclick="clicksvg(this)">Image Samples</font> |
<font face="arial" id="2" color="green" onclick="clicksvg(this)">Local Mean</font> |
<font face="arial" id="3" color="blue" onclick="clicksvg(this)">Direct predecessor</font> |
<font face="arial" id="4" color="red" onclick="clicksvg(this)">Differential predecessor</font></h2>
<script>
function clicksvg(e){
id = e.id
@ -18,7 +19,7 @@
}
</script>
</head>
<body>
<body bgcolor="#efefef">
<svg height="1200" viewBox="100 50 400 -400" width="3000" version="1.1"
xmlns="http://www.w3.org/2000/svg">
<desc>NLMSvariants output graph
@ -32,31 +33,19 @@
<path d="M 100 0 L 0 0 0 100" fill="none" stroke="gray" stroke-width="1"></path>
</pattern>
</defs>
<rect fill="white" height="1200" width="3000" y="0"></rect>
<rect fill="url(#grid10)" height="1200" width="3000" y="0"></rect>
<rect fill="white" height="800" width="3000" y="0"></rect>
<rect fill="url(#grid10)" height="800" width="3000" y="0"></rect>
<g transform="translate(0,0) scale(1, 1)">
<line class="l1 s-black " stroke="black" x1="-200" x2="3000" y1="400" y2="400"></line>
<line class="l1 s-black " stroke="black" x1="200" x2="200" y1="-200" y2="1200"></line>
<line class="l1 s-black " stroke="black" x1="50" x2="50" y1="-200" y2="800"></line>
</g>
<g transform="translate(200, 400) scale(1,-1)">
<g transform="translate(50, 400) scale(1,-1)">
<path d="M0 0
<text class="t36 t-mid bold f-black" x="50" y="50">+ +</text>
<text class="t36 t-mid bold f-black" x="-50" y="50">- +</text>
<text class="t36 t-mid bold f-black" x="50" y="-50">+ -</text>
<text class="t36 t-mid bold f-black" x="-50" y="-50">- -</text>
<text class="t36 t-mid bold f-black" x="40" y="40">+ +</text>
<text class="t36 t-mid bold f-black" x="-40" y="40">- +</text>
<text class="t36 t-mid bold f-black" x="40" y="-40">+ -</text>
<text class="t36 t-mid bold f-black" x="-40" y="-40">- -</text>
</g>
</svg>
<table width = "100%" border = 1>
<tr align = "top">
<td colspan = "2" bgcolor = "#fefefe">
<h1>
<font color="blue">Eingangswert</font> |
<font color="red">direkter Vorgaenger</font> |
<font color="green">letzter Mittelwert</font>
</h1>
</td>
</tr>
</body>
<html>

28
src/cpp_implementation/nlms_types.h Normal file
View File

@ -0,0 +1,28 @@
/* *svg graph building* */
typedef struct {
double xVal[7];
double yVal[7];
}point_t;
/* *ppm read, copy, write* */
typedef struct {
unsigned char red, green, blue;
}colorChannel_t;
typedef struct {
int x, y;
colorChannel_t *data;
}imagePixel_t;
enum fileSuffix_t{ // used in conjunction with mkFileName()
PURE_WEIGHTS,
USED_WEIGHTS,
DIRECT_PREDECESSOR,
RESULTS,
LOCAL_MEAN,
TEST_VALUES,
DIFFERENTIAL_PREDECESSOR
};