KernelLogisticRegression:
good code
KernelLogisticRegression:
good code
In this blog post
great blog post! would love some more detail on how you found the empirical loss
KernelLogisticRegression:
good code
https://github.com/juliafairbank7/juliafairbank7.github.io/tree/main/posts/logistic-regression-post
remember to link the write source code
minimize the empiricial risk
would love further detail on how you did this
noise and gamma.
blog post incomplete?
This blog post consists of three parts
good blog post and nice visuals!
s blog pos
good blog post! and good visuals
LogisticRegression
good code and comments
differs significantly
good blog post, would like a little explaination into why these different variables, when altered, change the model
LogisticRegression
good code and comments
Below is our data, which is not linearly separable.
good blog post, would like a little more explaination into why these different implementations lead to different results (e.g. why does a too-large alpha prevent convergence)
LogisticRegression:
good code
selected alpha size is too
why would this prevent convergence?
so the loss improves at a faster rate.
maybe explain a little into the why?
LogisticRegression:
good code and docstrings. you could also comment individual lines, but that's more of a stylistic preference than anything else, the docstrings were very informative
Experiment 2
it would be nice to have more explaination into why these differences between different momentum/alphas/batchsizes changed the loss and 'speed' of the loss
LogisticRegression:
good code and comments
slower rate.
great blog post!
LogisticRegression
good code! i'd recommend commenting individual lines, instead of a big block at the beginning of each method
Conclusion
great blog post
LogisticRegression:
good code, would like more comments explaining code
data set
talk about these findings! why are they different? why do the converge at different 'speeds'?
class Perceptron:
good code
orse score
there was additional questions that needed to be answered at the end of the blogpost. make sure to double check that
In class,
good math explaination
on my github
make this a little more obvious / at the beginning of the blog
features we have.
how is this represented in big-O?
class Perceptron:
good code
class Perceptron:
good code
The runtime complexity is dependent on the number of data points
i would go over this again and re-check your big-O
weights accordingly and update my counter.
would like more descriptions of the math
time complexity
go over description above, think about the relationship between n data points as n changes, but we are only looking at one of n
Writing 3.3
need written descriptions of each experiment
we quit the loop as we are done
maybe more math explanation/talk
The updating of the weights will happen
good
number of features
this is correct, re-check your Big-O above
vector.
good explanation
class Perceptron:
good code
single index
good
Breakdown of the Perceptron Algorithm
good descriptions
Experiment
before hopping into the experiments, write a section giving brief explaination of code/math performed in this blogpost (look at assignment)
runtime complexity
what is the runtime complexity though?
class Perceptron:
code looks good
class Perceptron:
code looks good
class Perceptron:
code looks good. solid efficiency