/* @overload initialize( inputs, targets ) * Creates a new dataset from example data. * @param [NArray<sfloat>] inputs the input examples that a nn_model will process * @param [NArray<sfloat>] targets known outputs that can be used to train or assess a nn_model * @return [RuNeNe::DataSet] new dataset */ VALUE dataset_class_initialize( VALUE self, VALUE rv_inputs, VALUE rv_targets ) { volatile VALUE val_inputs; volatile VALUE val_targets; struct NARRAY *na_inputs; struct NARRAY *na_targets; DataSet *dataset = get_dataset_struct( self ); val_inputs = na_cast_object( rv_inputs, NA_SFLOAT ); GetNArray( val_inputs, na_inputs ); val_targets = na_cast_object( rv_targets, NA_SFLOAT ); GetNArray( val_targets, na_targets ); if ( na_inputs->rank < 2 ) { rb_raise( rb_eArgError, "Inputs rank should be at least 2, but got %d", na_inputs->rank ); } if ( na_targets->rank < 2 ) { rb_raise( rb_eArgError, "Targets rank should be at least 2, but got %d", na_targets->rank ); } if ( na_inputs->shape[ na_inputs->rank - 1 ] != na_targets->shape[ na_targets->rank - 1 ] ) { rb_raise( rb_eArgError, "Number of input items %d not same as target items %d", na_inputs->shape[ na_inputs->rank - 1 ], na_targets->shape[ na_targets->rank - 1 ] ); } dataset__init_from_narray( dataset, val_inputs, val_targets ); return self; }
/* @overload from_weights( weights, transfer_label = :sigmoid ) * Creates a new layer using the supplied weights array, which must be rank 2. * The inputs and bias are taken from the first dimension, and each output is assigned * from the second dimension. For example an array with shape [5,3] has 4 inputs and * 3 outputs. * @param [NArray] weights * @param [Symbol] transfer_label type of transfer function to use. * @return [RuNeNe::Layer::FeedForward] new layer using supplied weights. */ VALUE layer_ff_class_from_weights( int argc, VALUE* argv, VALUE self ) { volatile VALUE weights_in, tfn_type; struct NARRAY *na_weights; volatile VALUE val_weights; int i, o; rb_scan_args( argc, argv, "11", &weights_in, &tfn_type ); val_weights = na_cast_object(weights_in, NA_SFLOAT); GetNArray( val_weights, na_weights ); if ( na_weights->rank != 2 ) { rb_raise( rb_eArgError, "Weights rank should be 2, but got %d", na_weights->rank ); } i = na_weights->shape[0] - 1; if ( i < 1 ) { rb_raise( rb_eArgError, "Input size %d is less than minimum of 1", i ); } o = na_weights->shape[1]; if ( o < 1 ) { rb_raise( rb_eArgError, "Output size %d is less than minimum of 1", o ); } return layer_ff_new_ruby_object_from_weights( val_weights, symbol_to_transfer_type( tfn_type ) ); }
/* @overload run( input ) * Runs nn_model forward and generates a result * @param [NArray<sfloat>] input single input vector * @return [NArray<sfloat>] output of nn_model */ VALUE nn_model_rbobject__run( VALUE self, VALUE rv_input ) { NNModel *nn_model = get_nn_model_struct( self ); int out_shape[1] = { nn_model->num_outputs }; struct NARRAY *na_input; volatile VALUE val_input = na_cast_object(rv_input, NA_SFLOAT); GetNArray( val_input, na_input ); // Shouldn't happen, but we don't want a segfault if ( nn_model->num_layers < 1 ) { return Qnil; } if ( na_input->total != nn_model->num_inputs ) { rb_raise( rb_eArgError, "Input array must be size %d, but it was size %d", nn_model->num_inputs, na_input->total ); } struct NARRAY *na_output; volatile VALUE val_output = na_make_object( NA_SFLOAT, 1, out_shape, cNArray ); GetNArray( val_output, na_output ); nn_model__run( nn_model, (float*) na_input->ptr ); memcpy( (float*) na_output->ptr, nn_model->activations[nn_model->num_layers-1], nn_model->num_outputs * sizeof(float) ); return val_output; }
VALUE openal_buffer_initialize(VALUE self, VALUE channelsVal, VALUE bitswidthVal, VALUE freqVal, VALUE data) { al_buffer_t *al_buffer; int rank; int frames; uint8_t *buf_8bit; int16_t *buf_16bit; int channels, bitswidth, freq; Data_Get_Struct(self, al_buffer_t, al_buffer); channels = NUM2INT(channelsVal); bitswidth = NUM2INT(bitswidthVal); freq = NUM2INT(freqVal); if (bitswidth == 8) { data = na_cast_object(data, NA_BYTE); buf_8bit = NA_PTR_TYPE(data, uint8_t *); }
/* @overload run( ) * Runs the layer with supplied input(s). The input array can be a single, one-dimensional * vector, or can be * @param [NArray<sfloat>] inputs * @return [NArray<sfloat>] */ VALUE layer_ff_object_run( VALUE self, VALUE rv_input ) { Layer_FF *layer_ff = get_layer_ff_struct( self ); int out_shape[1] = { layer_ff->num_outputs }; struct NARRAY *na_input; volatile VALUE val_input = na_cast_object(rv_input, NA_SFLOAT); GetNArray( val_input, na_input ); if ( na_input->total != layer_ff->num_inputs ) { rb_raise( rb_eArgError, "Input array must be size %d, but it was size %d", layer_ff->num_inputs, na_input->total ); } struct NARRAY *na_output; volatile VALUE val_output = na_make_object( NA_SFLOAT, 1, out_shape, cNArray ); GetNArray( val_output, na_output ); layer_ff__run( layer_ff, (float*) na_input->ptr, (float*) na_output->ptr ); return val_output; }