示例#1
0
/* @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;
}
示例#2
0
/* @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 ) );
}
示例#3
0
/* @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;
}
示例#4
0
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 *);
  }
示例#5
0
/* @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;
}