kissinference.h

/* * libkissinference - an inference libary for kiss networks
 * Copyright (C) 2024 Carl Philipp Klemm <carl@uvos.xyz>
 *
 * This file is part of libkissinference.
 *
 * libkissinference is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * libkissinference is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libkissinference.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
#include <stddef.h>
#include <stdbool.h>
 
#include "version.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct kiss_priv;
 
struct kiss_vector {
        const char *name; 
        float *values; 
        size_t length; 
};
 
struct kiss_network
{
        struct kiss_priv *priv;
 
        struct kiss_vector *inputs; 
        size_t input_count; 
        size_t output_size; 
        bool *output_mask; 
        char *purpose; 
        char **output_labels; 
        bool ready; 
        bool softmax; 
        float *output_scalars; 
        float *output_biases; 
        void (*result_cb)(float *result, struct kiss_network* net, void *user_data);
};
 
void kiss_free_network(struct kiss_network *net);
 
void kiss_free_network_prealloc(struct kiss_network *net);
 
struct kiss_network *kiss_load_network(const char *path, void (*result_cb)(float* result, struct kiss_network* net, void* user_data), bool verbose);
 
struct kiss_vector *kiss_create_vector(const char *name, float *values, size_t length);
 
void kiss_free_vector(struct kiss_vector *vector);
 
bool kiss_load_network_prealloc(struct kiss_network* net, const char *path, void (*result_cb)(float* result, struct kiss_network* net, void* user_data), bool verbose);
 
struct kiss_network *kiss_load_network_from_buffer(const char* buffer, size_t size, void (*result_cb)(float* result, struct kiss_network* net, void* user_data), bool verbose);
 
bool kiss_load_network_from_buffer_prealloc(struct kiss_network* net, const char* buffer, size_t size, void (*result_cb)(float* result, struct kiss_network* net, void* user_data), bool verbose);
 
bool kiss_async_run_inference(struct kiss_network *net, const struct kiss_vector *inputs, size_t inputs_count, void* user_data);
 
 
bool kiss_set_output_mask(struct kiss_network *net, const bool *output_mask);
 
size_t kiss_get_active_output_count(struct kiss_network *net);
 
float *kiss_create_range(float start, float end, size_t length, bool log);
 
void kiss_resample_spectra(float *in_re, float *in_im, size_t input_length, float **out_re, float **out_im, size_t output_length);
 
 
void kiss_normalize_spectra(float *in_re, float *in_im, size_t input_length);
 
 
bool kiss_reduce_spectra(float *in_re, float *in_im, float *omegas, size_t input_length,
                         float thresh_factor, bool use_second_deriv,
                         float **out_re, float **out_im, size_t *output_length);
 
bool kiss_filter_spectra(float *in_re, float *in_im, float *omegas, size_t input_length,
                         float **out_re, float **out_im, size_t output_length);
 
float *kiss_absgrad(float *in_re, float *in_im, float *omegas, size_t input_length, size_t index);
 
float kiss_grad(float *data, float *omegas, size_t input_length, size_t index);
 
float kiss_median(float *data, size_t input_length);
 
float kiss_mean(float *data, size_t input_length);
 
const char *kiss_get_strerror(struct kiss_network *net);
 
void kiss_softmax(float *data, size_t input_length);
 
void kiss_linear(float* data, float* weight, float* bias, size_t lengh);
 
void kiss_softmax_masked(float *data, bool *mask, size_t input_length);
 
bool kiss_float_eq(float a, float b, unsigned int ulp);
 
char* kiss_eis_to_relaxis(const char* in);
 
char* kiss_eis_to_cdc(const char* in);
 
void kiss_free(void *data);
 
#ifdef __cplusplus
}
#endif