you should remove commented out code snippets and nonused functions when the code works and is ready for submission

cool graph

looks good

looks good

looks good

looks good

looks like it works... you're missing the experiments on gamma fluctuation and circle data generation thought

all the commented out code create a lot of clutter- if your code works I'd remove the commented out snippets

same deal here

this is a bit confusing with the placement here... I'd move it above the corresponding graph and code block

sure, but you might want to include a few more batch sizes to show that there isn't an optimal batch size somewhere between 2 and 20

you want to prove that a large enough learning rate stops the algorithm from converging... try a larger value for alpha? if step size is too large you'll just end up with large oscillations that stops the model from converging

you can create a multi-line python comment with triple quotes- i.e.: """ comment """

sure, but what if we make learning rate really large? say 10, 50, or 100?

it would be nice to see your two graphs on the same plot so we can visually compare fit, stochastic, and stochastic with momentum

you need more elaborate docstrings explaining this and your stochastic method (as per part 3 of the assignment)

If the one with momentum only sometimes outperforms the one without, you can't really make this claim for the general case. It does with your code and some of the cases you tested, but that doesn't necessarily mean it does on a general basis

If you're going to make a claim like this, it makes sense to visualize more than two different batch sizes (1,2,5,10,20?) to prove it

interesting that your graph seems to get disconnected after each local maximum... could be worth looking into

what's small enough? at what point do they no longer converge? does it differ between the algorithms?

you could also do this in one step with something like np.random.randint

It would be nice to see some illustrations of your data and the accuracy/loss over time of each algorithm similar to Prof Chodrows

Looks good

It looks like you're missing parts 2&3 (experiments and documentation)

typo

same here & throughout

doesn't look like this is rendering the way you intended

your code is a bit hard to read- including some comments and blocking the code a bit more would be helpful

I assume this is to override a division by zero error? regardless it would be better to write conditional checks or find another way to solve the error than just muting it

not sure about this. The runtime shouldn't be O(# data points) - the significant operation is the calculation of the update step

You missed experiment 3

unnecessary

unnecessary

I would have expected the line to at least intersect some of the data, so this is an interesting final position for the dividing line- it doesn't seem optimized for the data

looks good

you could also do this with a for loop and a break statement if the accuracy condition is reached

everything here looks good

not a serious issue but I'd recommend using same plotting function for every graph just for consistency's sake

the predict function is actually not strictly necessary for model training because that it is just used for recording historical accuracy.

instead of assigning centers at random, try assigning them such that you can ensure there is no overlap between the data points (as we saw in experiment 2 can cause problems) and see if the algorithm can classify them

could be worth explaining a bit what the equation is actually doing here.

you're missing the last part of the assignment regarding runtime analysis

same thing here- a line graph would be a great way to visualize this data

same thing here

it would be helpful to see a graph of accuracy over all time... this doesn't tell the reader very much

I really like this- great example

you don't really need this if you're plotting the accuracy over time right after

code looks good

you don't explicitly need this here, randint will assume the second parameter is the upper bound

you could add a check here to make sure that w does not already exist which would let you run fit multiple times if you want to do more training - not strictly necessary for this case though

code looks good

why? its more readable to have them as the same scale

please see the assignment instructions- you need to include your perceptron implementation code, the third experiment, and a runtime analysis (for a single iteration).

better practice might be to call this once inside the function when you add it to history and then check if the most recent item in history is a 1 (if so, break). This works though, I'm just nitpicking (also if you do it this way you can use a for loop instead of a while loop)

here you might want to add a check to make sure that the weights haven't already been initialized in case you want to call the fit function multiple times for more training- not necessary because you're only calling it once, but good practice