subsasgn.m

RBF网络逼近、RBF-建模、RBF网络训练与测试程序

  % other
  case 'userdata',
    [net.userdata,err] = nsubsasn(net.userdata,subscripts,v);

  otherwise, error('Reference to non-existent field.');
  end
  
case '{}',error('Cell contents assignment to a non-cell array object.')
case '()',error('Array contents assignment to a non-array object.')
end

% Read only values
net.numOutputs = sum(net.outputConnect);
net.numTargets = sum(net.targetConnect);
net.numInputDelays = 0;
for i=1:net.numLayers
  for j=find(net.inputConnect(i,:))
    net.numInputDelays = max([net.numInputDelays net.inputWeights{i,j}.delays]);
  end
end
net.numLayerDelays = 0;
for i=1:net.numLayers
  for j=find(net.layerConnect(i,:))
    net.numLayerDelays = max([net.numLayerDelays net.layerWeights{i,j}.delays]);
  end
end
for i=1:net.numLayers
  net.layers{i}.positions = feval(net.layers{i}.topologyFcn,net.layers{i}.dimensions);
  if length(net.layers{i}.distanceFcn) > 0
    net.layers{i}.distances = feval(net.layers{i}.distanceFcn,net.layers{i}.positions);
  else
    net.layers{i}.distances = [];
  end
end

% Error message
if length(err), error(err), end

% % Update hints if not OK and UPDATE is on
if ~net.hint.ok
  net = hint(net);
end

% ===========================================================
%                          WEIGHT AND BIAS VALUES
% ===========================================================
function [net,err] = setiw(net,IW)

err = '';

if ~isa(IW,'cell')
  err = sprintf('net.IW must be a %g-by-%g cell array.',net.numLayers,net.numInputs);
  return
end
if any(size(IW) ~= [net.numLayers net.numInputs])
  err = sprintf('net.IW must be a %g-by-%g cell array.',net.numLayers,net.numInputs);
  return
end
for i=1:net.numLayers
  for j=1:net.numInputs
    if ~isa(IW{i,j},'double')
      if (net.inputConnect(i,j))
        err = sprintf('net.IW{%g,%g} must be a %g-by-%g matrix.',i,j,net.inputWeights{i,j}.size);
    return
      else
        err = sprintf('net.IW{%g,%g} must be an empty matrix.',i,j,net.inputWeights{i,j}.size);
    return
      end
    end
  if net.inputConnect(i,j)
      if any(size(IW{i,j}) ~= net.inputWeights{i,j}.size)
        err = sprintf('net.IW{%g,%g} must be a %g-by-%g matrix.',i,j,net.inputWeights{i,j}.size);
    return
      end
      net.IW{i,j} = IW{i,j};
    else
      if prod(size(IW{i,j})) ~= 0
      err = sprintf('net.IW{%g,%g} must be an empty matrix.',i,j);
    return
      end
    end
  end
end

% ===========================================================
function [net,err] = setlw(net,LW)

err = '';

if ~isa(LW,'cell')
  err = sprintf('net.LW must be a %g-by-%g cell array.',net.numLayers,net.numLayers);
  return
end
if any(size(LW) ~= [net.numLayers net.numLayers])
  err = sprintf('net.LW must be a %g-by-%g cell array.',net.numLayers,net.numLayers);
  return
end
for i=1:net.numLayers
  for j=1:net.numLayers
    if ~isa(LW{i,j},'double') & ~islogical(LW{i,j})
      if (net.layerConnect(i,j))
        err = sprintf('net.LW{%g,%g} must be a %g-by-%g matrix.',i,j,net.layerWeights{i,j}.size);
    return
      else
        err = sprintf('net.LW{%g,%g} must be an empty matrix.',i,j,net.layerWeights{i,j}.size);
    return
      end
    end
  if net.layerConnect(i,j)
      if any(size(LW{i,j}) ~= net.layerWeights{i,j}.size)
        err = sprintf('net.LW{%g,%g} must be a %g-by-%g matrix.',i,j,net.layerWeights{i,j}.size);
    return
      end
      net.LW{i,j} = LW{i,j};
    else
      if prod(size(LW{i,j})) ~= 0
      err = sprintf('net.LW{%g,%g} must be an empty matrix.',i,j);
    return
      end
    end
  end
end

% ===========================================================
function [net,err] = setb(net,B)

err = '';

if ~isa(B,'cell')
  err = sprintf('net.b must be a %g-by-1 cell array.',net.numLayers);
  return
end
if any(size(B) ~= [net.numLayers 1])
  err = sprintf('net.b must be a %g-by-1 cell array.',net.numLayers);
  return
end
for i=1:net.numLayers
    if ~isa(B{i},'double')
      if (net.biasConnect(i))
        err = sprintf('net.b{%g} must be a %g-by-1 matrix.',i,net.biases{i}.size);
    return
      else
        err = sprintf('net.b{%g} must be an empty matrix.',i,net.biases{i}.size);
    return
      end
    end
  if net.biasConnect(i)
      if any(size(B{i}) ~= [net.biases{i}.size 1])
        err = sprintf('net.b{%g} must be a %g-by-1 matrix.',i,net.biases{i}.size);
    return
      end
      net.b{i} = B{i};
    else
      if prod(size(B{i})) ~= 0
      err = sprintf('net.b{%g} must be an empty matrix.',i);
    return
      end
    end
end

% ===========================================================
%                          ARCHITECTURE
% ===========================================================
function [net,err] = setNumInputs(net,numInputs)

err = '';
if ~isposint(numInputs)
  err = '"numInputs" must be a positive integer or zero.';
  return
end

if (numInputs < net.numInputs)

  keep = 1:numInputs;
  net.inputs = net.inputs(keep);
  
  net.inputConnect = net.inputConnect(:,keep);
  net.inputWeights = net.inputWeights(:,keep);
  
  net.IW = net.IW(:,keep);
  
elseif (numInputs > net.numInputs)
  Input = {nninput};
  extend = numInputs - net.numInputs;
  net.inputs = [net.inputs; Input(ones(extend,1))];
  
  net.inputConnect = [net.inputConnect zeros(net.numLayers,extend)];
  net.inputWeights = [net.inputWeights cell(net.numLayers,extend)];
  
  net.IW = [net.IW cell(net.numLayers,extend)];
end

net.numInputs = numInputs;

% ===========================================================
function [net,err] = setNumLayers(net,numLayers)

err = '';
if ~isposint(numLayers)
  err = '"numLayers" must be a positive integer or zero.';
  return
end

if (numLayers < net.numLayers)

  keep = 1:numLayers;
  net.layers = net.layers(keep);
  
  net.biasConnect = net.biasConnect(keep,1);
  net.inputConnect = net.inputConnect(keep,:);
  net.layerConnect = net.layerConnect(keep,keep);
  net.outputConnect = net.outputConnect(1,keep);
  net.targetConnect = net.outputConnect(1,keep);

  net.biases = net.biases(keep,1);
  net.inputWeights = net.inputWeights(keep,:);
  net.layerWeights = net.layerWeights(keep,keep);
  net.outputs = net.outputs(1,keep);
  net.targets = net.targets(1,keep);
  
  net.b = net.b(1:numLayers,1);
  net.IW = net.IW(keep,:);
  net.LW = net.LW(keep,keep);
  
elseif (numLayers > net.numLayers)

  Layer = {nnlayer};
  extend = numLayers-net.numLayers;
  net.layers = [net.layers; Layer(ones(extend,1))];
  
  net.biasConnect = [net.biasConnect; zeros(extend,1)];
  net.inputConnect = [net.inputConnect; zeros(extend,net.numInputs)];
  net.layerConnect = [net.layerConnect zeros(net.numLayers,extend); zeros(extend,numLayers)];
  net.outputConnect = [net.outputConnect zeros(1,extend)];
  net.targetConnect = [net.targetConnect zeros(1,extend)];
  
  net.biases = [net.biases; cell(extend,1)];
  net.inputWeights = [net.inputWeights; cell(extend,net.numInputs)];
  net.layerWeights = [net.layerWeights cell(net.numLayers,extend); cell(extend,numLayers)];
  net.outputs = [net.outputs cell(1,extend)];
  net.targets = [net.targets cell(1,extend)];
  
  net.b = [net.b; cell(extend,1)];
  net.IW = [net.IW; cell(extend,net.numInputs)];
  net.LW = [net.LW cell(net.numLayers,extend); cell(extend,numLayers)];
end

net.numLayers = numLayers;

% ===========================================================
function [net,err] = setBiasConnect(net,biasConnect)

err = '';
if ~isbool(biasConnect,net.numLayers,1);
  err = sprintf('"biasConnect" must be a %gx1 boolean matrix.',net.numLayers);
  return
end

for i=findne(net.biasConnect,biasConnect)'
  if biasConnect(i) == 1
    net.biases{i} = nnbias;
    net.biases{i}.size = net.layers{i}.size;
  net.b{i} = zeros(net.layers{i}.size,1);
  else
    net.biases{i} = [];
  net.b{i} = [];
  end
end

net.biasConnect = biasConnect;

% Invalidate Hints
net.hint.ok = 0;

% ===========================================================
function [net,err] = setInputConnect(net,inputConnect)

% Check value
err = '';
if ~isbool(inputConnect,net.numLayers,net.numInputs);
  err = sprintf('"inputConnect" must be a %gx%g boolean matrix.',net.numLayers,net.numInputs);
  return
end

% Add and remove weights
for i=1:net.numLayers
  for j=findne(inputConnect(i,:),net.inputConnect(i,:))
    if inputConnect(i,j)
    net.inputWeights{i,j} = nnweight;
    rows = net.layers{i}.size;
      cols = net.inputs{j}.size * length(net.inputWeights{i,j}.delays);
      net.inputWeights{i,j}.size = [rows cols];
      net.IW{i,j} = zeros(rows,cols);
    else
    net.inputWeights{i,j} = [];
    net.IW{i,j} = [];
  end
  
  end
end

% Change input connect
net.inputConnect = inputConnect;

% ===========================================================
function [net,err] = setLayerConnect(net,layerConnect)

err = '';
if ~isbool(layerConnect,net.numLayers,net.numLayers);
  err = sprintf('"layerConnect" must be a %gx%g boolean matrix.',net.numLayers,net.numLayers);
  return
end

% Add and remove weights
for i=1:net.numLayers
  for j=findne(layerConnect(i,:),net.layerConnect(i,:))
  
  if layerConnect(i,j)
      net.layerWeights{i,j} = nnweight;
    rows = net.layers{i}.size;
    cols = net.layers{j}.size * length(net.layerWeights{i,j}.delays);
    net.layerWeights{i,j}.size = [rows cols];
    net.LW{i,j} = zeros(rows,cols);
  else
   net.layerWeights{i,j} = [];
   net.LW{i,j} = [];
  end
  
  end
end

% Change layer connect
net.layerConnect = layerConnect;

% ===========================================================
function [net,err] = setOutputConnect(net,outputConnect)

err = '';
if ~isbool(outputConnect,1,net.numLayers);
  err = sprintf('"outputConnect" must be a 1x%g boolean matrix.',net.numLayers);
  return
end

for i=findne(net.outputConnect,outputConnect)
  if outputConnect(i) == 1
    net.outputs{i} = nnoutput;
    net.outputs{i}.size = net.layers{i}.size;
  else
    net.outputs{i} = [];
  end
end

net.outputConnect = outputConnect;

% ===========================================================
function [net,err] = setTargetConnect(net,targetConnect)

err = '';
if ~isbool(targetConnect,1,net.numLayers);
  err = sprintf('"targetConnect" must be a 1x%g boolean matrix.',net.numLayers);
  return
end

for i=findne(net.targetConnect,targetConnect)
  if targetConnect(i) == 1
    net.targets{i} = nntarget;
  net.targets{i}.size = net.layers{i}.size;
  else
    net.targets{i} = [];
  end
end

net.targetConnect = targetConnect;

% ===========================================================
%                          INPUT PROPERTIES
% ===========================================================

function [net,err] = setInputRange(net,j,range)

% Check value
err = '';
if ~isrealmat(range,NaN,2)
  err = sprintf('"inputs{%g}.range" must an Rx2 real matrix.',j);
  return
end
if any(range(:,1) > range(:,2))
  err = sprintf('First column elements in "inputs{%g}.range" must be smaller than the second.',j);
  return
end

% Change input size
newSize = size(range,1);
net.inputs{j}.size = newSize;

% Change range size
net.inputs{j}.range = range;

% Change weight sizes
for i=find(net.inputConnect(:,j)')
  rows = net.layers{i}.size;
  cols = net.inputs{j}.size * length(net.inputWeights{i,j}.delays);
  net.inputWeights{i,j}.size = [rows cols];
  net.IW{i,j} = resizem(net.IW{i,j},rows,cols);
end

% ===========================================================

function [net,err] = setInputSize(net,j,newSize)

% Check value
err = '';
if ~isposint(newSize)
  err = sprintf('"inputs{%g}.size" must be a positive integer.',j);
  return
end

% Change input size
net.inputs{j}.size = newSize;

% Change range size
net.inputs{j}.range = setmrows(net.inputs{j}.range,newSize,[0 1]);

% Change weight value size