City Search – v1.0

-
For this assignment, we created three search algorithms to find routes between cities, or points, on a map.

Each algorithm is slightly different, however, they all have the same basic structure. Starting at an origin city, the neighboring ("connected") cities are loaded into a queue with a certain cost (distance, for example). The lowest cost city is opened next, and its neighboring cities are added to the queue.

Uniform Search

Uniform search is the simplest of them all. As each city is loaded into the queue, the cost is calculated by finding the distance between the current city and the neighboring city. When the target city is found, a route is declared. The cost for the route is the sum of all the distances traveled between the cities.

Greedy Search

Greedy search is also relatively simple. Instead of queued cities being sorted by the distance between this and the next, they are sorted by the distance from the target city (as the crow flies). This can lead to some wildly expensive results. For example, the next city may be close to the target city, but the distance to get there is overly expensive.

A* Search

A-star searches combine the two searches from above; that is, the cost is the distance between the current city and next, plus the distance from the target city (again, as the crow flies). Of these three search algorithms, A* is widely considered the fastest and most efficient. This is because the search is "guided" by the distance to the target, so it doesn't start searching in the opposite direction of the target city.


Comments

Post a Comment

Popular updates

Half Moon Project Part 2 - More Accuracy

-
Image
This time around, we used the Neuroph library to create a neural network  that can divide the double half-moons more accurately. Neural Networks A Neural Network is a combination of Neurons that feed into each other. Using some really complex math, they can weight each input (from a previous Neuron) differently. Then, after training, they can use backpropagation to calculate which weights should be edited. What this looks like can be seen below. More Accuracy for Half-Moons Since, previously, we were only using one neuron to calculate the line to separate the two moons, we could only draw a linear line. This time, with a more complex neural network, it can separate the two with a function that's super complicated. Theoretically, a human could also derive the equation, but it's so complex that at this point, it's easier to get the Neural Network to do it for us.
Read more

NumberVision – Machine Learning Application

-
Image
The next way we used our Neuron class was to classify digits. Using a UI, our program was assigned to take an input digit (a 5x7 grid, each box has a shade of grey between black and white) and classify the digit as a number between 0 and 9. A Smarter Neuron Graphical depiction of a Neuron receiving more than 2 inputs. Previously, I had only been using a Neuron with two inputs: an X and Y coordinate. Previously, this allowed me to plot my points on a plane like I did with the Half Moon project. However, due to the 5x7 grid of inputs I was getting, I had to alter my Neuron class to be able to take in 35 inputs. Mostly, this involved changing a few numbers.  Applying the Neuron to NumberVision The digit '1', with progressively more noise added from left to right. Good algorithms should be able to generate a result even if the input is a little distorted. I applied the same goal to NumberVision. The flow chart above shows various levels of added distortio
Read more

Machine Learning & Half Moon Project

-
Image
This was our first Machine Learning assignment. Machine Learning is something that I was (and still am) super excited about. Basically, the algorithm 'learns' something, and can then apply it in other situations. Learning & Neurons This was the toughest concept to learn (ha). We started with a Neuron, similar to the neurons in our brains. The neuron can trigger (yes/no) based on a series of inputs, in our case two inputs. The equation for whether or not the neuron triggers is SUMMATION(Weight(n) * Input(n)) > threshold . Each input is weighted differently, and the weights are what we can change to 'train' the neuron. We use this equation:  ΔWeight = learningSpeed * (target - output) * input . For example, if we start with a speed of 0.2, an input of 1, a weight of 0.5, and a target of 0, the weight would change by -0.2 (0.2 * (1 - 0) * 1). Now, with a weight of 0.3, repeat the process. Once each input returns the desired output, the best weights have been fo
Read more