https://github.com/AgamAgarwal/facial-expression-recognition
facial-expression-recognition
To Do:
Sort featurepoints locally by x-axis.
Error handling for detectmineigenfeature when bounding box returned is empty.
Test on new data.
| Datasets for Machine Learning (0) | 2016.12.16 |
|---|---|
| Guided Regularized Random Forest (발표자: 박찬희) (0) | 2016.12.15 |
| L1 Norm / L2 Norm (0) | 2016.11.23 |
| Machine Learning FAQ (0) | 2016.11.23 |
| libsvm에서 roc curve그리기 (0) | 2016.10.27 |
http://mathworld.wolfram.com/L2-Norm.html
matlab : https://www.mathworks.com/matlabcentral/answers/146264-how-to-perform-l2-normalization
If v is the vector do:
v = v/norm(v);
(The 'norm' function gives L2 norm as a default.)
| Guided Regularized Random Forest (발표자: 박찬희) (0) | 2016.12.15 |
|---|---|
| facial-expression-recognition matlab code (0) | 2016.11.29 |
| Machine Learning FAQ (0) | 2016.11.23 |
| libsvm에서 roc curve그리기 (0) | 2016.10.27 |
| Accuracy, Sensitivity, and Specificity (0) | 2016.10.26 |
It is always a pleasure to engage in discussions about machine learning. Below, I collected some of the most frequently asked questions that I answered via email or other social network platforms in hope that these are useful to others!
The only thing to do with good advice is to pass it on. It is never of any use to oneself.
— Oscar Wilde
| facial-expression-recognition matlab code (0) | 2016.11.29 |
|---|---|
| L1 Norm / L2 Norm (0) | 2016.11.23 |
| libsvm에서 roc curve그리기 (0) | 2016.10.27 |
| Accuracy, Sensitivity, and Specificity (0) | 2016.10.26 |
| 머신러닝 관련 포스트 번역 (0) | 2016.08.11 |
Machine learning was described by Arthur Samuel as the "field of study that gives computers the ability to learn without being explicitly programmed".
The following three principles are central to Machine Learning:
The last point raises the following question - how much data is needed in order to learn?
Two related concepts can give us insight as to why we are able to learn from data, and how does having more data help us to learn--these are Hoeffding's Inequality and the law of large numbers.
Consider an infinite bin, from which we take a sample of size , which we find to have a sample frequency, . However, the bin frequency, , is unknown. However, Hoeffding's Inequality allows us to calculate a probability bound between these two quantities, i.e.:
This inequality applies to a single bin, and is valid for all and and the bound does not depend on .
It illustrates the tradeoff between , , and the bound, i.e. the larger the sample size, , the smaller our probability bound. On the other hand, the smaller the tolerance, , the harder it will be to keep the probability small.
A related concept is the weak law of large numbers, given by:
As the sample size, , approaches infinity, the probability approaches zero.
Further Reading:
The following Python libraries are used in this exercise
from __future__ import print_function, division
import numpy as np
import matplotlib.pyplot as plt
import itertools
np.set_printoptions(edgeitems=3,infstr='inf',linewidth=75,nanstr='nan',precision=4,suppress=False,threshold=1000,formatter=None)
%matplotlib inline
In this example, we intend to "learn" a Boolean target function. The function takes in input vector of size 3, say [0, 1, 0] or [0, 1, 1] and outputs a single output, , which can be zero or 1. If we enumerate the set of all possible target functions, we would have distinct Boolean functions on 3 Boolean inputs.
In this example, we wish to score 4 different hypotheses, based on how well they perform on "out of sample points". The scoring system is 1 point per correct point, i.e. if the function gets 3 "out of sample points" correct, it will get a score of 3. We wish to calcuate the total score when enumerating over the entire set of all possible functions.
In the code below, the 256 distinct Boolean functions are enumerated using itertools.product([0,1],repeat=8) and a score is calculated for each of 4 possible cases. It is determined that the score for each of these cases is identical.
def calculate_score_last3(y,g):
total_score=0
for y_last in y[:,5:]:
total_score += np.sum(y_last==g)
return total_score
g_a = np.vstack(np.array([1,1,1,1,1]))
g_b = np.vstack(np.array([0,0,0,0,0]))
g_c = np.vstack(np.array([0,1,1,0,1]))
g_d = np.logical_not(g_a).astype(int)
y = np.array(list(itertools.product([0,1],repeat=8)))
print("Scores:\n(a) {}\n(b) {}\n(c) {}\n(d) {}".format(
calculate_score_last3(y,[1,1,1]),
calculate_score_last3(y,[0,0,0]),
calculate_score_last3(y,[0,0,1]),
calculate_score_last3(y,[1,1,0])))
The Perceptron is attributed to the work of Frank Rosenblatt in 1957. It is a binary classifier that works on the basis of whether a dot product, , exceeds a certain threshold:
This can be written in the form of a hypothesis given by:
To generate the sample data for the perceptron classifier above, a three-column random matrix with the first column as ones is created as follows:
def generate_data(n,seed=None):
if seed is not None:
np.random.seed(seed)
x0 = np.ones(n)
x1 = np.random.uniform(low=-1,high=1,size=(2,n))
return np.vstack((x0,x1)).T
The region of interest is , where denotes the Cartesian Product.
A random line is created, and to ensure that it falls within the region of interest, it is created from two random points, and which are generated within . The equation for this line in slope-intercept form and in the hypothesis / weights form are derived as follows.
The hypothesis, in the two dimensional case (), and since :
The decision boundary, is given by:
This can be converted to the slope-intercept form if we take to be the axis, and to be the axis, i.e.:
Comparison with the equation yields the following relationships:
If we arbitrarily set , we arrive at the following set of weights, which is consistent with the decision boundary denoted by :
def get_random_line(seed=None):
X = generate_data(2,seed=seed)
x = X[:,1]
y = X[:,2]
m = (y[1]-y[0])/(x[1]-x[0])
c = y[0] - m*x[0]
return np.array([-c,-m,1])
def draw_line(ax,w,marker='g--',label=None):
m = -w[1]/w[2]
c = -w[0]/w[2]
x = np.linspace(-1,1,20)
y = m*x + c
if label is None:
ax.plot(x,y,marker)
else:
ax.plot(x,y,marker,label=label)
def get_hypothesis(X,w):
h=np.dot(X,w)
return np.sign(h).astype(int)
The following code generates a training dataset (separated into positive and negative classes according to a random line in ) and plots it.
def plot_data(fig,plot_id,X,y=None,w_arr=None,my_x=None,title=None):
ax = fig.add_subplot(plot_id)
if y is None:
ax.plot(X[:,1],X[:,2],'gx')
else:
ax.plot(X[y > 0,1],X[y > 0,2],'b+',label='Positive (+)')
ax.plot(X[y < 0,1],X[y < 0,2],'ro',label='Negative (-)')
ax.set_xlim(-1,1)
ax.set_ylim(-1,1)
ax.grid(True)
if w_arr is not None:
if isinstance(w_arr,list) is not True:
w_arr=[w_arr]
for i,w in enumerate(w_arr):
if i==0:
draw_line(ax,w,'g-',label='Theoretical')
else:
draw_line(ax,w,'g--')
if my_x is not None:
ax.plot([my_x[0]],[my_x[1]],'kx',markersize=10)
if title is not None:
ax.set_title(title)
ax.legend(loc='best',frameon=True)
def create_dataset(N,make_plot=True,seed=None):
X = generate_data(N,seed=seed)
w_theoretical = get_random_line()
y = get_hypothesis(X,w_theoretical)
if make_plot is True:
fig = plt.figure(figsize=(7,5))
plot_data(fig,111,X,y,w_theoretical,title="Initial Dataset")
return X,y,w_theoretical
The Preceptron Learning Algorithm (PLA) is implemented in the following steps
The code below also keeps track of the weights, misclassification error, and misclassified point at each iteration.
def PLA(w,X,y0,n_iterations=10,verbose=True):
assert len(y0)==X.shape[0]
n=len(y0)
x_arr = list()
w_arr = list()
m_arr = list()
for i in range(n_iterations):
h = get_hypothesis(X,w)
bad = h != y0
bad = np.argwhere(bad).flatten()
if len(bad) > 0:
idx = np.random.choice(bad,1)[0]
my_x = X[idx,:]
m_arr.append(100.0*len(bad)/n)
x_arr.append(my_x)
w_arr.append(np.copy(w))
w += np.dot(y0[idx],my_x)
if verbose is True:
print("iter {}: {}% misclassified, w={}" \
.format(i,m_arr[-1],w_arr[-1]))
else:
m_arr.append(0.0)
x_arr.append(np.array([1.0, np.nan,np.nan]))
w_arr.append(np.copy(w))
if verbose is True:
print("iter {}: zero misclassified (PLA has converged)".format(i))
return w,w_arr,m_arr,x_arr
print("PLA failed to converge after {} iterations".format(i))
return None,None,None,None
Here, we generate a sample dataset of 10 points and plot it. The perceptron learning algorithm, starting from an initial weight of , converges in less than 10 iterations.
X,y,w_theoretical = create_dataset(N=10,make_plot=True,seed=247)
w0 = np.array([0,0,0],dtype=float)
w,w_arr,m_arr,x_arr = PLA(w0,X,y,n_iterations=100,verbose=True)
def draw_plot_steps(fig,plot_id,X,y,w_theoretical,w_arr,x_arr,idx_arr):
assert len(idx_arr) <= 9
for idx in idx_arr:
print("w_arr[{}] = {}, x_arr[{}] = {}".format(idx,w_arr[idx],idx,x_arr[idx][1:]))
plot_data(fig,plot_id,X,y,[w_theoretical] + [w_arr[idx]],
x_arr[idx][1:],title="iteration {}".format(idx))
plot_id += 1
fig = plt.figure(figsize=(10,15))
draw_plot_steps(fig,421,X,y,w_theoretical,w_arr,x_arr,np.arange(len(w_arr)-1)+1)
def plot_convergence(m_arr):
fig = plt.figure(figsize=(7,5))
ax = fig.add_subplot(111)
ax.plot(m_arr,'g+-',markersize=10)
ax.grid(True)
ax.set_title("Convergence")
ax.set_xlabel("Iterations")
ax.set_ylabel("Misclassification Error (%)")
plot_convergence(m_arr)
The following code calculates the number of iterations required for convergence and plots its distribution.
def plot_histogram(my_count,bins=200,x_max=80):
fig = plt.figure(figsize=(7,5))
ax = fig.add_subplot(111)
ax.hist(my_count,bins=bins);
ax.set_xlim(0,x_max)
ax.grid(True)
def get_iteration_distribution(N,n_trials=1000,max_iterations=10000,summary=True):
n_iterations=np.zeros(n_trials,dtype=int)
w0 = np.array([0,0,0],dtype=float)
for i in range(n_trials):
X,y,w_theoretical = create_dataset(N=N,make_plot=False,seed=None)
w,w_arr,m_arr,x_arr = PLA(w0,X,y,n_iterations=max_iterations,verbose=False)
n_iterations[i]=len(w_arr)
if summary is True:
print("Minumum iterations: {}".format(np.min(n_iterations)))
print("Maximum iterations: {}".format(np.max(n_iterations)))
print("Mean iterations: {}".format(np.mean(n_iterations)))
return n_iterations
n_iterations = get_iteration_distribution(N=10,n_trials=1000)
plot_histogram(n_iterations,bins=200,x_max=50)
If we know the theoretical decision boundary, w_theoretical, that 'knows' the correct classification of points, we can calculate the number of points misclassified by w (the final weights after convergence using the PLA) via random sampling. The misclassification error is slightly less than 20%.
def calculate_misclassification(w_theoretical,w,n_samples=1000,verbose=True):
X = generate_data(n_samples,seed=None)
y0 = get_hypothesis(X,w_theoretical)
y = get_hypothesis(X,w)
n_correct = np.sum(y == y0)
if verbose is True:
if w_theoretical[0] != 0.0:
print("Theoretical Weights : {}".format(w_theoretical/w_theoretical[0]))
else:
print("Theoretical Weights : {}".format(w_theoretical))
print("PLA Predicted Weights: {}".format(w))
print("Correct points = {}".format(n_correct))
print("Incorrect points = {}".format(n_samples-n_correct))
print("Misclassification= {}%".format(np.round(100 * (n_samples-n_correct)/n_samples, 4)))
fig = plt.figure(figsize=(7,5))
plot_data(fig,111,X,y0,[w_theoretical,w])
return (n_samples-n_correct)/n_samples
misclassification = calculate_misclassification(w_theoretical,w,verbose=True)
misclassification
def plot_misclassification(my_count,bins=20,x_max=0.25):
fig = plt.figure(figsize=(7,5))
ax = fig.add_subplot(111)
ax.hist(my_count,bins=bins);
ax.set_xlim(0,x_max)
ax.grid(True)
def get_misclassification_distribution(N=10,n_trials=1000,max_iterations=10000,summary=True):
w0 = np.array([0,0,0],dtype=float)
misclassification=np.zeros(n_trials)
for i in range(n_trials):
X,y,w_theoretical = create_dataset(N,make_plot=False,seed=None)
w,w_arr,m_arr,x_arr = PLA(w0,X,y,n_iterations=max_iterations,verbose=False)
misclassification[i]=calculate_misclassification(w_theoretical,w,n_samples=1000,verbose=False)
if summary is True:
print("Minumum misclassification: {}".format(np.min(misclassification)))
print("Maximum misclassification: {}".format(np.max(misclassification)))
print("Mean misclassification: {}".format(np.mean(misclassification)))
return misclassification
Here, we find that for =10, an average of about 10 iterations is required for convergence. The average misclassification error is about 10%.
n_iterations = get_iteration_distribution(N=10,n_trials=1000)
plot_histogram(n_iterations,bins=100,x_max=40)
misclassification = get_misclassification_distribution(N=10)
plot_misclassification(misclassification,bins=20,x_max=0.4)
For =100, an average of about 80~100 iterations is required for convergence. The average misclassification error is slightly over ~1%.
n_iterations = get_iteration_distribution(N=100,n_trials=1000)
plot_histogram(n_iterations,bins=300,x_max=300)
misclassification = get_misclassification_distribution(N=100)
plot_misclassification(misclassification,bins=40,x_max=0.05)
X,y,w_theoretical = create_dataset(N=100,make_plot=True,seed=12345)
w0 = np.array([0,0,0],dtype=float)
w,w_arr,m_arr,x_arr = PLA(w0,X,y,n_iterations=1000,verbose=False)
plot_convergence(m_arr)
fig = plt.figure(figsize=(8,7))
plot_data(fig,111,X,y,[w_theoretical] + w_arr)
| How do I start AI/ML/DL? (0) | 2017.03.18 |
|---|---|
| Machine Learning/Neural Networks recommended courses (0) | 2017.03.16 |
| Machine Learning with MATLAB video lectures (0) | 2016.12.30 |
| machine learning course by Professor Andrew Ng - Lecture notes and exercise code (0) | 2016.12.15 |
| Andrew Ng's Machine Learning lectures list (0) | 2016.12.14 |
http://stackoverflow.com/questions/23696609/what-are-the-matlab-perfcurve-roc-curve-parameters
see documentation of percurve, posclass is the label of positive class, in your case it has to be either 1,-1 or 2 http://www.mathworks.com/help/stats/perfcurve.html
ROC curve have "false positive rate" on x axis and "true positive rate on y axis". By specifying the posclass, you are specifying with respect to which class you are calculating false positive rate and true positive rate. e.g. if you specify posclass as 2, you consider that when the true label is 2, predicting either 1 or -1 is considered a false prediction (false negative).
Edit: The accuaracy_score you metioned (in my version of the documentation(3.17, in matlab folder), it is called decision_values/prob_estimates) have 3 column, each column correspond to the probability of the data belonging to one class.
e.g.
model=svmtrain(train_label,train_data);
[predicted_label, accuracy, decision_values]=predict(test_label,test_dat,model);model.Label contains the class labels, individual columns in decision_values contains probability of the the test case belong to class specified in model.Label.(see http://www.csie.ntu.edu.tw/~b91082/SVM/README).
to use purfcurve to compute ROC for class m:
[X,Y] = perfcurve(truelabels, decision_values(:,m)*model.Label(m),model.Label(m));It is essential to do decision_values(:,m)*model.Label(m) especially when you class label is a negative number.
| L1 Norm / L2 Norm (0) | 2016.11.23 |
|---|---|
| Machine Learning FAQ (0) | 2016.11.23 |
| Accuracy, Sensitivity, and Specificity (0) | 2016.10.26 |
| 머신러닝 관련 포스트 번역 (0) | 2016.08.11 |
| Machine learning - → Professur Künstliche Intelligenz (0) | 2016.03.09 |
http://www.lifenscience.com/bioinformatics/sensitivity-specificity-accuracy-and
Accuracy= (Sensitivity + Specificity)/2. In the case where, the number of excellent candidates and poor performers are equal
Predicted
pos. neg.
True Positive | a | b |
Negative | c | d |
위와 같은 표에서 a+b = c+d일때, 즉, Positive set과 Negative set이 같을 때에는 Accuracy = (Sensitivity+Specificity)/2이다.
Accuracy = (a+d)/(a+b+c+d)
Sensitivity = a/(a+b)
Specificity = d/(c+d)
Sensitivity, Specificity, and Accuracy are the terms which are most commonly associated with a Binary classification test and they statistically measure the performance of the test. In a binary classification, we divide a given data set into two categories on the basis of whether they have common properties or not by identifying their significance and in a binary classification test, as the name itself conveys, we deal with two datasets. Of these two categories, in general, Sensitivity indicates, how well the test predicts one category and Specificity measures how well the test predicts the other category. Whereas Accuracy is expected to measure how well the test predicts both categories.
|
Correctly Selected ---> True Positive (Excellent candidates correctly selected in box ‘Selected’) = 2 Mistakenly Selected ---> False Positive (Poor candidates wrongly selected in box ‘Selected’) = 2 Correctly Rejected ---> True Negative (Poor candidates correctly selected in box ‘Rejected’) = 2 Mistakenly Rejected ---> False Negative (Excellent candidates wrongly selected in box ‘Rejected’) = 2 |
| Sensitivity = True Positive / True Positive + False Negative = Correctly Selected / Correctly Selected + Mistakenly Rejected = Correctly Selected/ Total Excellent candidates who actually deserved Selection |
| Specificity = True Negative/ True Negative + False Positive = Correctly Rejected / Correctly Rejected + Mistakenly Selected = Correctly Rejected/ Total poor candidates who actually deserved Rejection |
| Accuracy = (True Positive +True Negative)/ (True Positive+ False Positive + True Negative + False Negative) = (Correctly Selected + Correctly Rejected)/ (Correctly Selected + Mistakenly Selected + Correctly Rejected + Mistakenly Rejected) = (Correctly Selected + Correctly Rejected)/ (Total Excellent candidates who actually deserved Selection + Total poor candidates who actually deserved Rejection) |
| Machine Learning FAQ (0) | 2016.11.23 |
|---|---|
| libsvm에서 roc curve그리기 (0) | 2016.10.27 |
| 머신러닝 관련 포스트 번역 (0) | 2016.08.11 |
| Machine learning - → Professur Künstliche Intelligenz (0) | 2016.03.09 |
| Introduction to Machine Learning - 3/3 (0) | 2013.08.23 |
안녕하세요. 눈팅만 하다가 처음 글을 쓰네요.
평소 국내 머신러닝 연구자분들이 번역해주시는 자료들을 잘 읽고 있었는데요
요새, 머신러닝 관련 좋은 영어 블로그 포스트가 많이 나와서
좀 자세히 읽어보려는 목적으로, 글을 번역해서 블로그에 올리고 있습니다. 제가 영어실력이 미천하여서, 좋은 번역이라고는 할수 없고 자신도없어서 번역된것으로 훑어보시고, 더 자세히는 원문읽는식으로 혹시나 도움이 되실분들이 있을까 해서 공유해봅니다. 감사합니다.
쉽게 쓰여진 MCMC:
http://blog.naver.com/rupy400/220775812498
자연어 처리 문제를 해결하는 CONVOLUTIONAL NEURAL NETWORKS 이해하기 :
http://blog.naver.com/rupy400/220776488979
IMPLEMENTING A CNN FOR TEXT CLASSIFICATION IN TENSORFLOW (한글 번역) :
http://blog.naver.com/rupy400/220777178142
딥러닝 챗봇, PART 1 – INTRODUCTION (한글번역) :
http://blog.naver.com/rupy400/220781279491
딥러닝 챗봇 , PART 2 – IMPLEMENTING A RETRIEVAL-BASED MODEL IN TENSORFLOW(한글번역):
http://blog.naver.com/rupy400/220781859893
| libsvm에서 roc curve그리기 (0) | 2016.10.27 |
|---|---|
| Accuracy, Sensitivity, and Specificity (0) | 2016.10.26 |
| Machine learning - → Professur Künstliche Intelligenz (0) | 2016.03.09 |
| Introduction to Machine Learning - 3/3 (0) | 2013.08.23 |
| Introduction to Machine Learning - 2/3 (0) | 2013.08.23 |
https://www.tu-chemnitz.de/informatik/KI/edu/ml/
The course will present an introduction to the research field of Machine Learning, including Supervised Learning, Unsupervised Learning and Reinforcement Learning methods. The different algorithms presented during the lectures will be studied in more details during the exercises, through implementations in Python. Previous knowledge of Python is a plus.
The plan of the course is:
Prerequisites: Modules in Mathematics I to IV, basic knowledge in Python.
Exam: oral examination (20 minutes), 5 credit points.
Contact: julien dot vitay at informatik dot tu-chemnitz dot de.
Exam dates in 2016: 16.02, 22.02, 23.02, 29.02, 01.03, 02.03 and 03.03.
Registration closed! Deregistration is only possible until one week prior to the appointment. No rescheduling possible.
Exam location: in my office 1/348.
Surya Narayana Varma Ruddaraju: empty your mailbox! Your exam is on 02.03 at 10:45.
------------------------------------------------------------------------------
| Accuracy, Sensitivity, and Specificity (0) | 2016.10.26 |
|---|---|
| 머신러닝 관련 포스트 번역 (0) | 2016.08.11 |
| Introduction to Machine Learning - 3/3 (0) | 2013.08.23 |
| Introduction to Machine Learning - 2/3 (0) | 2013.08.23 |
| Introduction to Machine Learning - 1/3 (0) | 2013.08.23 |
http://cs.brown.edu/courses/archive/2006-2007/cs195-5/calendar.html
Note: All handouts and lecture slides are in PDF format. Any scheduling information posted for future dates should be treated as tentative.
Abbreviation: DHS - Duda et al.; PRML - Bishop's new book; HTF - Hastie et al.; NNPR - Bishop's older book; MK - MacKay.
Mon 9/11/06 Note: change of location to CIT 368
Wed 9/13/06
Fri 9/15/06 In Lubrano, our new home
Mon 9/18/06
Wed 9/20/06
Fri 9/22/06
Mon 9/25/06
Wed 9/27/06
Fri 9/29/06
Mon 10/2/06
Wed 10/4/06
Fri 10/6/06
Mon 10/9/06
Wed 10/11/06
Fri 10/13/06
Mon 10/16/06
Wed 10/18/06
Fri 10/20/06
Mon 10/23/06
Wed 10/25/06
Fri 10/27/06 CIT 367
Mon 10/30/06
Wed 11/1/06
Fri 11/3/06
Mon 11/6/06
Wed 11/8/06
Fri 11/10/06
Mon 11/13/06
Wed 11/15/06
Fri 11/17/06
Mon 11/20/06
Wed 11/22/06
Fri 11/24/06
Mon 11/27/06
Wed 11/29/06
Fri 12/1/06
Mon 12/4/06
Wed 12/6/06
Fri 12/8/06
Mon 12/11/06
Wed 12/13/06
Fri 12/15/06
Mon 12/18/06
| Accuracy, Sensitivity, and Specificity (0) | 2016.10.26 |
|---|---|
| 머신러닝 관련 포스트 번역 (0) | 2016.08.11 |
| Machine learning - → Professur Künstliche Intelligenz (0) | 2016.03.09 |
| Introduction to Machine Learning - 2/3 (0) | 2013.08.23 |
| Introduction to Machine Learning - 1/3 (0) | 2013.08.23 |
http://cs.brown.edu/courses/archive/2006-2007/cs195-5/calendar.html
Note: All handouts and lecture slides are in PDF format. Any scheduling information posted for future dates should be treated as tentative.
Abbreviation: DHS - Duda et al.; PRML - Bishop's new book; HTF - Hastie et al.; NNPR - Bishop's older book; MK - MacKay.
Mon 9/11/06 Note: change of location to CIT 368
Wed 9/13/06
Fri 9/15/06 In Lubrano, our new home
Mon 9/18/06
Wed 9/20/06
Fri 9/22/06
Mon 9/25/06
Wed 9/27/06
Fri 9/29/06
Mon 10/2/06
Wed 10/4/06
Fri 10/6/06
Mon 10/9/06
Wed 10/11/06
Fri 10/13/06
Mon 10/16/06
Wed 10/18/06
Fri 10/20/06
Mon 10/23/06
Wed 10/25/06
Fri 10/27/06 CIT 367
Mon 10/30/06
Wed 11/1/06
Fri 11/3/06
Mon 11/6/06
Wed 11/8/06
Fri 11/10/06
Mon 11/13/06
Wed 11/15/06
Fri 11/17/06
Mon 11/20/06
Wed 11/22/06
Fri 11/24/06
Mon 11/27/06
Wed 11/29/06
Fri 12/1/06
Mon 12/4/06
Wed 12/6/06
Fri 12/8/06
Mon 12/11/06
Wed 12/13/06
Fri 12/15/06
Mon 12/18/06
| Accuracy, Sensitivity, and Specificity (0) | 2016.10.26 |
|---|---|
| 머신러닝 관련 포스트 번역 (0) | 2016.08.11 |
| Machine learning - → Professur Künstliche Intelligenz (0) | 2016.03.09 |
| Introduction to Machine Learning - 3/3 (0) | 2013.08.23 |
| Introduction to Machine Learning - 1/3 (0) | 2013.08.23 |
http://cs.brown.edu/courses/archive/2006-2007/cs195-5/calendar.html
Note: All handouts and lecture slides are in PDF format. Any scheduling information posted for future dates should be treated as tentative.
Abbreviation: DHS - Duda et al.; PRML - Bishop's new book; HTF - Hastie et al.; NNPR - Bishop's older book; MK - MacKay.
Mon 9/11/06 Note: change of location to CIT 368
Wed 9/13/06
Fri 9/15/06 In Lubrano, our new home
Mon 9/18/06
Wed 9/20/06
Fri 9/22/06
Mon 9/25/06
Wed 9/27/06
Fri 9/29/06
Mon 10/2/06
Wed 10/4/06
Fri 10/6/06
Mon 10/9/06
Wed 10/11/06
Fri 10/13/06
Mon 10/16/06
Wed 10/18/06
Fri 10/20/06
Mon 10/23/06
Wed 10/25/06
Fri 10/27/06 CIT 367
Mon 10/30/06
Wed 11/1/06
Fri 11/3/06
Mon 11/6/06
Wed 11/8/06
Fri 11/10/06
Mon 11/13/06
Wed 11/15/06
Fri 11/17/06
Mon 11/20/06
Wed 11/22/06
Fri 11/24/06
Mon 11/27/06
Wed 11/29/06
Fri 12/1/06
Mon 12/4/06
Wed 12/6/06
Fri 12/8/06
Mon 12/11/06
Wed 12/13/06
Fri 12/15/06
Mon 12/18/06
| Accuracy, Sensitivity, and Specificity (0) | 2016.10.26 |
|---|---|
| 머신러닝 관련 포스트 번역 (0) | 2016.08.11 |
| Machine learning - → Professur Künstliche Intelligenz (0) | 2016.03.09 |
| Introduction to Machine Learning - 3/3 (0) | 2013.08.23 |
| Introduction to Machine Learning - 2/3 (0) | 2013.08.23 |
|
| 일 | 월 | 화 | 수 | 목 | 금 | 토 |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | |||
| 5 | 6 | 7 | 8 | 9 | 10 | 11 |
| 12 | 13 | 14 | 15 | 16 | 17 | 18 |
| 19 | 20 | 21 | 22 | 23 | 24 | 25 |
| 26 | 27 | 28 | 29 | 30 | 31 |
exercise1-solution.zip
exercise1.pdf
IntroML.vol3.egg
