func mergeNetworkPayloads(networkPayloads []spec.NetworkPayload) (spec.NetworkPayload, error) { if len(networkPayloads) == 0 { return nil, maskAny(networkPayloadNotFoundError) } var args []reflect.Value var sources []string for _, np := range networkPayloads { for _, v := range np.GetArgs() { args = append(args, v) } sources = append(sources, np.GetSources()...) } ctx := networkPayloads[0].GetContext() behaviourID, ok := ctx.GetBehaviourID() if !ok { return nil, maskAnyf(invalidBehaviourIDError, "must not be empty") } networkPayloadConfig := networkpayload.DefaultConfig() networkPayloadConfig.Args = args networkPayloadConfig.Context = ctx networkPayloadConfig.Destination = string(behaviourID) networkPayloadConfig.Sources = sources networkPayload, err := networkpayload.New(networkPayloadConfig) if err != nil { return nil, maskAny(err) } return networkPayload, nil }
func testMustNew(t *testing.T, ctx objectspec.Context, input string) objectspec.NetworkPayload { newNetworkPayloadConfig := networkpayload.DefaultConfig() newNetworkPayloadConfig.Args = []reflect.Value{reflect.ValueOf(input)} newNetworkPayloadConfig.Context = ctx newNetworkPayloadConfig.Destination = "destination" newNetworkPayloadConfig.Sources = []string{"source"} newNetworkPayload, err := networkpayload.New(newNetworkPayloadConfig) if err != nil { t.Fatal("expected", nil, "got", err) } return newNetworkPayload }
func (f *forwarder) GetNetworkPayloads(CLG systemspec.CLG, networkPayload objectspec.NetworkPayload) ([]objectspec.NetworkPayload, error) { ctx := networkPayload.GetContext() // Check if there are behaviour IDs known that we can use to forward the // current network payload to. behaviourID, ok := ctx.GetBehaviourID() if !ok { return nil, maskAnyf(invalidBehaviourIDError, "must not be empty") } behaviourIDsKey := key.NewNetworkKey("forward:configuration:behaviour-id:%s:behaviour-ids", behaviourID) newBehaviourIDs, err := f.Storage().General().GetAllFromSet(behaviourIDsKey) if storage.IsNotFound(err) { // No configuration of behaviour IDs is stored. Thus we return an error. // Eventually some other lookup is able to find sufficient network payloads. return nil, maskAny(networkPayloadsNotFoundError) } else if err != nil { return nil, maskAny(err) } // Create a list of new network payloads. var newNetworkPayloads []objectspec.NetworkPayload for _, behaviourID := range newBehaviourIDs { // Prepare a new context for the new network payload. newCtx := ctx.Clone() newCtx.SetBehaviourID(behaviourID) // Create a new network payload. newNetworkPayloadConfig := networkpayload.DefaultConfig() newNetworkPayloadConfig.Args = networkPayload.GetArgs() newNetworkPayloadConfig.Context = newCtx newNetworkPayloadConfig.Destination = string(behaviourID) newNetworkPayloadConfig.Sources = []string{networkPayload.GetDestination()} newNetworkPayload, err := networkpayload.New(newNetworkPayloadConfig) if err != nil { return nil, maskAny(err) } newNetworkPayloads = append(newNetworkPayloads, newNetworkPayload) } return newNetworkPayloads, nil }
func (n *network) Calculate(CLG systemspec.CLG, networkPayload objectspec.NetworkPayload) (objectspec.NetworkPayload, error) { n.Log.WithTags(systemspec.Tags{C: nil, L: "D", O: n, V: 13}, "call Calculate") outputs, err := filterError(reflect.ValueOf(CLG.GetCalculate()).Call(networkPayload.GetCLGInput())) if err != nil { return nil, maskAny(err) } newNetworkPayloadConfig := networkpayload.DefaultConfig() newNetworkPayloadConfig.Args = outputs newNetworkPayloadConfig.Context = networkPayload.GetContext() newNetworkPayloadConfig.Destination = networkPayload.GetDestination() newNetworkPayloadConfig.Sources = networkPayload.GetSources() newNetworkPayload, err := networkpayload.New(newNetworkPayloadConfig) if err != nil { return nil, maskAny(err) } return newNetworkPayload, nil }
func (f *forwarder) News(CLG systemspec.CLG, networkPayload objectspec.NetworkPayload) ([]objectspec.NetworkPayload, error) { ctx := networkPayload.GetContext() // Decide how many new behaviour IDs should be created. This defines the // number of signals being forwarded to other CLGs. Here we want to make a // pseudo random decision. CreateMax takes a max paramater which is exclusive. // Therefore we increment the configuration for the maximum signals desired by // one, to reflect the maximum setting properly. maxSignals, err := f.Service().Random().CreateMax(f.GetMaxSignals() + 1) if err != nil { return nil, maskAny(err) } // Create the desired number of behaviour IDs. var newBehaviourIDs []string for i := 0; i < maxSignals; i++ { newBehaviourID, err := f.Service().ID().New() if err != nil { return nil, maskAny(err) } newBehaviourIDs = append(newBehaviourIDs, string(newBehaviourID)) } // TODO find a CLG name that can be connected to the current CLG for each new // behaviour ID and pair these combinations (network event tracker) // Store each new behaviour ID in the underlying storage. behaviourID, ok := ctx.GetBehaviourID() if !ok { return nil, maskAnyf(invalidBehaviourIDError, "must not be empty") } behaviourIDsKey := key.NewNetworkKey("forward:configuration:behaviour-id:%s:behaviour-ids", behaviourID) for _, behaviourID := range newBehaviourIDs { // TODO store asynchronuously err = f.Storage().General().PushToSet(behaviourIDsKey, behaviourID) if err != nil { return nil, maskAny(err) } } // Create a list of new network payloads. var newNetworkPayloads []objectspec.NetworkPayload for _, behaviourID := range newBehaviourIDs { // Prepare a new context for the new network payload. newCtx := ctx.Clone() newCtx.SetBehaviourID(behaviourID) // TODO set the paired CLG name to the new context // Create a new network payload. newNetworkPayloadConfig := networkpayload.DefaultConfig() newNetworkPayloadConfig.Args = networkPayload.GetArgs() newNetworkPayloadConfig.Context = newCtx newNetworkPayloadConfig.Destination = string(behaviourID) newNetworkPayloadConfig.Sources = []string{networkPayload.GetDestination()} newNetworkPayload, err := networkpayload.New(newNetworkPayloadConfig) if err != nil { return nil, maskAny(err) } newNetworkPayloads = append(newNetworkPayloads, newNetworkPayload) } return newNetworkPayloads, nil }
func (n *network) InputHandler(CLG systemspec.CLG, textInput objectspec.TextInput) error { // In case the text request defines the echo flag, we overwrite the given CLG // directly to the output CLG. This will cause the created network payload to // be forwarded to the output CLG without indirection. Note that this should // only be used for testing purposes to bypass more complex neural network // activities to directly respond with the received input. if textInput.GetEcho() { var ok bool CLG, ok = n.CLGs["output"] if !ok { return maskAnyf(clgNotFoundError, "name: %s", "output") } } // Create new IDs for the new CLG tree and the input CLG. clgTreeID, err := n.Service().ID().New() if err != nil { return maskAny(err) } behaviourID, err := n.Service().ID().New() if err != nil { return maskAny(err) } // Create a new context and adapt it using the information of the current scope. ctx := context.MustNew() ctx.SetBehaviourID(string(behaviourID)) ctx.SetCLGName(CLG.GetName()) ctx.SetCLGTreeID(string(clgTreeID)) ctx.SetExpectation(textInput.GetExpectation()) ctx.SetSessionID(textInput.GetSessionID()) // We transform the received text request to a network payload to have a // conventional data structure within the neural network. newNetworkPayloadConfig := networkpayload.DefaultConfig() newNetworkPayloadConfig.Args = []reflect.Value{reflect.ValueOf(textInput.GetInput())} newNetworkPayloadConfig.Context = ctx newNetworkPayloadConfig.Destination = behaviourID newNetworkPayloadConfig.Sources = []string{n.GetID()} newNetworkPayload, err := networkpayload.New(newNetworkPayloadConfig) if err != nil { return maskAny(err) } // Write the new CLG tree ID to reference the input CLG ID and add the CLG // tree ID to the new context. firstBehaviourIDKey := key.NewNetworkKey("clg-tree-id:%s:first-behaviour-id", clgTreeID) err = n.Storage().General().Set(firstBehaviourIDKey, string(behaviourID)) if err != nil { return maskAny(err) } // Write the transformed network payload to the queue. eventKey := key.NewNetworkKey("event:network-payload") b, err := json.Marshal(newNetworkPayload) if err != nil { return maskAny(err) } err = n.Storage().General().PushToList(eventKey, string(b)) if err != nil { return maskAny(err) } return nil }
func (c *clg) forwardNetworkPayload(ctx spec.Context, informationSequence string) error { // Find the original information sequence using the information ID from the // context. informationID, ok := ctx.GetInformationID() if !ok { return maskAnyf(invalidInformationIDError, "must not be empty") } informationSequenceKey := key.NewNetworkKey("information-id:%s:information-sequence", informationID) informationSequence, err := c.Storage().General().Get(informationSequenceKey) if err != nil { return maskAny(err) } // Find the first behaviour ID using the CLG tree ID from the context. The // behaviour ID we are looking up here is the ID of the initial input CLG. clgTreeID, ok := ctx.GetCLGTreeID() if !ok { return maskAnyf(invalidCLGTreeIDError, "must not be empty") } firstBehaviourIDKey := key.NewNetworkKey("clg-tree-id:%s:first-behaviour-id", clgTreeID) inputBehaviourID, err := c.Storage().General().Get(firstBehaviourIDKey) if err != nil { return maskAny(err) } // Lookup the behaviour ID of the current output CLG. Below we are using this // to set the source of the new network payload accordingly. outputBehaviourID, ok := ctx.GetBehaviourID() if !ok { return maskAnyf(invalidBehaviourIDError, "must not be empty") } // Create a new contect using the given context and adapt the new context with // the information of the current scope. newCtx := ctx.Clone() newCtx.SetBehaviourID(inputBehaviourID) newCtx.SetCLGName("input") newCtx.SetCLGTreeID(clgTreeID) // We do not need to set the expectation because it never changes. // We do not need to set the session ID because it never changes. // Create a new network payload. newNetworkPayloadConfig := networkpayload.DefaultConfig() newNetworkPayloadConfig.Args = []reflect.Value{reflect.ValueOf(informationSequence)} newNetworkPayloadConfig.Context = newCtx newNetworkPayloadConfig.Destination = string(inputBehaviourID) newNetworkPayloadConfig.Sources = []string{string(outputBehaviourID)} newNetworkPayload, err := networkpayload.New(newNetworkPayloadConfig) if err != nil { return maskAny(err) } // Write the transformed network payload to the queue. networkPayloadKey := key.NewNetworkKey("events:network-payload") b, err := json.Marshal(newNetworkPayload) if err != nil { return maskAny(err) } err = c.Storage().General().PushToList(networkPayloadKey, string(b)) if err != nil { return maskAny(err) } return nil }