German Shepherd dogs

 

This popped up on my post, and is a great insight into how habitat grazing works in some parts of Germany.

 

"

Pat Tagg wrote

 

"I recently spent CPD time with a Master Shepherd in Northern Europe. Learning and renewing the very finest skills required to work with very large numbers of animals in open environments.

There are no fences.

There are often significant walks between grazing areas (forget the idea that this work is a simple lure). The task is to ensure that patches of the countryside are grazed properly, both to sustain the sheep but also to protect native flora and fauna.

In this short clip you will hear a single whistle made by the Meister Schãfer. It is delivered at a particular volume, tone and duration which is distinct. This was a sheep whistle. The signals for the dogs are whispered and is almost inaudible. (try to ignore the people speaking in the background).

This whistle calls sheep to come back from the lateral edges of the grazing area as they have wandered out of sight. No dog is deployed. The dogs are hanging around at our feet just in case the road side (behind the camera) needs protecting. Otherwise the dogs lay around with us just watching quietly or mucking about playing with each other.

Sheep top and bottom of the grazing area do not react. The grazing area has already been eaten (although not yet grazed as closely as is required for good management, we were not yet ready to move on). This is not a whistle which indicates 'new food'. This is the result of good training. This is the result of positive reinforcement.

Reinforcment in this case comes from the social cohesion of being part of the flock, flocking algorithmns, the Meister Schãfer can signal to the sheep that these are stretching and bring the sheep back together. Endogenous reinforcement takes place (this is breed specific not all sheep flocking ethology is the same).

Reward can occur at any additional time if and when the flock move off. Sheep are not threatened with a dog or lured with a new field. Their bond with the shepherd is key. Sheep do not follow all humans. Sheep follow shepherds that they trust.

These are incredibly fine communicative skills and they are incredibly difficult to acquire (ask my Shepherd School students, they are all trying to do just that). I have recently been disappointed to read that some people think it is time we farmers START learning how to do this stuff and that we need to learn how to do it from pet or zoo examples. I beg to differ......."

 

I couldn't include the video, but it showed a flock of large, clipped, floppy eared sheep spread out and sure enough when the shepheherd whistled a few hurried back to the group.

Cleary a very specialised form of shepherding;  Pat Tagg has her own large flock, keeps a GSD to manage them in the tradtional way, and gives lessons to keep the skills going.

Define 'endogenus reinforcement...'

"All behavior change derives from the reinforcing or deterring effect of instantaneous payoff experiences. Payoff experiences are reinforcing or deterring depending on whether the payoff exceeds an aspiration level or falls short of it. Over time, the aspiration level is adjusted toward the actually experienced payoffs. This article shows that aspiration level adjustments may improve the decision maker's long-run performance by preventing him or her from feeling dissatisfied with even the best available strategies. However, such movements also lead to persistent deviations from expected payoff maximization by creating ‘probability matching’ effects."

 

I also googled 'flocking algorithems'

3 Simple Rules of Flocking Behaviors: Alignment, Cohesion, and Separation

by Vijay Pemmaraju21 Jan 2013
Difficulty:IntermediateLength:ShortLanguages:
English
Pусский
ProgrammingPlatform AgnosticFlash

In the natural world, organisms exhibit certain behaviors when traveling in groups. This phenomenon, also known as flocking, occurs at both microscopic scales (bacteria) and macroscopic scales (fish). Using computers, these patterns can be simulated by creating simple rules and combining them. This is known as emergent behavior, and can be used in games to simulate chaotic or life-like group movement.

Note: Although this tutorial is written using Flash and AS3, you should be able to use the same techniques and concepts in almost any game development environment.

Introduction

In this tutorial, I will cover the three main rules used to simulate flocking and explain how to implement each one.  Before we begin, here's some terminology I'll be using:

Agent: A single entity or character.
Velocity vector: An agent's current velocity.
Neighborhood: A certain area around the agent, used to look for other agents.
Resultant: The vector obtained from the calculations of the rule.

This demo shows the effects of the three flocking rules which I'll explain in this tutorial: alignment, cohesion, and separation.

The full source code for this demo can be downloaded here, so this article will only highlight the most important aspects of the implementation. Feel free to download the source if you wish to learn more.

Alignment

Image adapted from Craig Reynolds' article

Alignment is a behavior that causes a particular agent to line up with agents close by.

First, we'll make a function that takes an agent and returns a velocity vector.

1
2
3
public function computeAlignment(myAgent:Agent):Point
{
}

We'll need two variables: one for storing the vector we'll compute, and another for keeping track of the number of neighbors of the agent.

1
2
var v:Point = new Point();
var neighborCount = 0;

With our variables initialized, we now iterate through all of the agents and find the ones within the neighbor radius - that is, those close enough to be considered neighbors of the specified agent. If an agent is found within the radius, its velocity is added to the computation vector, and the neighbor count is incremented.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
for each (var agent:Agent in agentArray)
{
    if (agent != myAgent)
    {
        if (myAgent.distanceFrom(agent) < 300)
        {
            v.x += agent.velocity.x;
            v.y += agent.velocity.y;
            neighborCount++;
        }
 
    }
 
}

If no neighbors were found, we simply return the zero vector (the default value of the computation vector).

1
2
if (neighborCount == 0)
    return v;

Finally, we divide the computation vector by the neighbor count and normalize it (divide it by its length to get a vector of length 1), obtaining the final resultant vector.

1
2
3
4
v.x /= neighborCount;
v.y /= neighborCount;
v.normalize(1);
return v;

Cohesion

Image adapted from Craig Reynolds' article

Cohesion is a behavior that causes agents to steer towards the "center of mass" - that is, the average position of the agents within a certain radius.

The implementation is almost identical to that of the alignment behavior, but there are some key differences. First, instead of adding the velocity to the computation vector, the position is added instead.

1
2
v.x += agent.x;
v.y += agent.y;

Like before, the computation vector is divided by the neighbor count, resulting in the position that corresponds to the center of mass. However, we don't want the center of mass itself, we want the direction towards the center of mass, so we recompute the vector as the distance from the agent to the center of mass. Finally, this value is normalized and returned.

1
2
3
4
5
v.x /= neighborCount;
v.y /= neighborCount;
v = new Point(v.x - myAgent.x, v.y - myAgent.y);
v.normalize(1);
return v;

Separation

Image adapted from Craig Reynolds' article

Separation is the behavior that causes an agent to steer away from all of its neighbors.

The implementation of separation is very similar to that of alignment and cohesion, so I'll only point out what is different. When a neighboring agent is found, the distance from the agent to the neighbor is added to the computation vector.

1
2
v.x += agent.x - myAgent.x;
v.y += agent.y - myAgent.y

The computation vector is divided by the corresponding neighbor count, but before normalizing, there is one more crucial step involved. The computed vector needs to be negated in order for the agent to steer away from its neighbors properly.

1
2
v.x *= -1;
v.y *= -1;

Putting It All Together

Once these three rules have been implemented, they need to come together. The simplest way to do this is as follows:

1
2
3
4
5
6
7
8
var alignment = computeAlignment(agent);
var cohesion = computeCohesion(agent);
var separation = computeSeparation(agent);
 
agent.velocity.x += alignment.x + cohesion.x + separation.x;
agent.velocity.y += alignment.y + cohesion.y + separation.y;
 
agent.velocity.normalize(AGENT_SPEED);

Here, I simply compute the three rules for a particular agent, and add them to the velocity. I then normalize the velocity and then multiply by some constant representing the default speed for an agent.It is possible to enhance this further by adding weights for each rule to tweak the behaviors:

1
2
agent.velocity.x += alignment.x * alignmentWeight + cohesion.x * cohesionWeight + separation.x * separationWeight;
agent.velocity.y += alignment.y * alignmentWeight + cohesion.y * cohesionWeight + separation.y * separationWeight;

Modifying these weights will change the way the agents flock. Be sure to experiment with the numbers until you find something you like.