def least_squares_fit(xs: List[Vector], ys: List[float], learning_rate: float = 0.001, num_steps: int = 1000, batch_size: int = 1) -> Vector: """ Find the beta that minimizes the sum of squared errors assuming the model y = dot(x, beta) """ # Start with a random guess guess = [random.random() for _ in xs[0]] for _ in tqdm.trange(num_steps, desc="least squares fit"): for start in range(0, len(xs), batch_size): batch_xs = xs[start:start + batch_size] batch_ys = ys[start:start + batch_size] gradient = vector_mean([ sqerror_gradient(x, y, guess) for x, y in zip(batch_xs, batch_ys) ]) guess = gradient_step(guess, gradient, -learning_rate) return guess
def scale(data: List[Vector]) -> Tuple[Vector, Vector]: """returns the means and standard deviations for each position""" dim = len(data[0]) means = vector_mean(data) stdevs = [standard_deviation([vector[i] for vector in data]) for i in range(dim)] return means, stdevs
def cluster_means(k, inputs, assignments): clusters = [[] for i in range(k)] for input, assignment in zip(inputs, assignments): clusters[assignment].append(input) return [ vector_mean(cluster) if cluster else random.choice(inputs) for cluster in clusters ]
def scale(data): dim = len(data[0]) means = vector_mean(data) stdevs = [ standard_deviation([vector[i] for vector in data]) for i in range(dim) ] return means, stdevs
def cluster_means(k: int, inputs: List[Vector], assignments: List[int]) -> List[Vector]: # clusters[i] contains the inputs whose assignment is i clusters = [[] for i in range(k)] for input, assignment in zip(inputs, assignments): clusters[assignment].append(input) # if a cluster is empty, just use a random point return [vector_mean(cluster) if cluster else random.choice(inputs) for cluster in clusters]
def cluster_means( k: int, inputs: List[Vector], assignments: List[int]) -> List[Vector]: # 클러스터 소속을 표시하는 번호 리스트 clusters = [[] for i in range(k)] for input, assignment in zip(inputs, assignments): clusters[assignment].append(input) # if a cluster is empty, just use a random point return [ vector_mean(cluster) if cluster else random.choice(inputs) for cluster in clusters ]
def cluster_means(k: int, inputs: List[Vector], assignments: List[int]) -> List[Vector]: # clusters[i] zawiera punkty, które są przypisane do i clusters = [[] for i in range(k)] for input, assignment in zip(inputs, assignments): clusters[assignment].append(input) # jeżeli klaster jest pusty, użyj losowego punktu return [ vector_mean(cluster) if cluster else random.choice(inputs) for cluster in clusters ]
def least_squares_fit(xs: List[Vector], ys: List[float], learning_rate: float = 0.001, num_steps: int = 1000, batch_size: int = 1) -> Vector: guess = [random.random() for _ in xs[0]] for _ in tqdm.trange(num_steps, desc="least squares fit"): for start in range(0, len(xs), batch_size): batch_xs = xs[start:start + batch_size] batch_ys = ys[start:start + batch_size] gradient = vector_mean([ squared_gradient(x, y, guess) for x, y in zip(batch_xs, batch_ys) ]) guess = gradient_step(guess, gradient, -learning_rate) return guess
def least_squares_fit_ridge(xs: List[Vector], ys: List[float], alpha: float, learning_rate: float, num_steps: int, batch_size: int = 1) -> Vector: # Rozpoczynamy od średniej guess = [random.random() for _ in xs[0]] for i in range(num_steps): for start in range(0, len(xs), batch_size): batch_xs = xs[start:start + batch_size] batch_ys = ys[start:start + batch_size] gradient = vector_mean([ sqerror_ridge_gradient(x, y, guess, alpha) for x, y in zip(batch_xs, batch_ys) ]) guess = gradient_step(guess, gradient, -learning_rate) return guess
def minibatches(dataset: List[T], batch_size: int, shuffle: bool = True) -> Iterator[List[T]]: #dataset에서 batch_size만큼 데이터 포인트를 샘플링해서 미니배치를 생성 #각 미니배치의 시작점인 0, batch_size, 2 * batch_size, ...을 나열 batch_starts = [start for start in range(0, len(dataset), batch_size)] if shuffle: random.shuffle(batch_starts) #미니배치의 순서를 섞는다. for start in batch_starts: end = start + batch_size yield dataset[start:end] #미니배치 theta = [random.uniform(-1, 1), random.uniform(-1, 1)] for epoch in range(1000): for batch in minibatches(inputs, batch_size=20): grad = vector_mean( [linear_gradient(x, y, theta) for x, y in batch]) theta = gradient_step(theta, grad, -learning_rate) print(epoch, theta) slope, intercept = theta assert 19.9 < slope < 20.1 assert 4.9 < intercept < 5.1 #SGD(stochastic gradient descent) for epoch in range(500): for x, y in inputs: grad = linear_gradient(x, y, theta) theta = gradient_step(theta, grad, -learning_rate) print(epoch, theta) slope, intercept = theta assert 19.9 < slope < 20.1 assert 4.9 < intercept < 5.1
def least_squares_fit(xs: List[Vector], ys: List[float], learning_rate: float = 0.001, num_steps: int = 1000, batch_size: int = 1) -> Vector: """ Znajdź beta, które minimalizuje sumę kwadratów błędów, zakładając model y = dot(x, beta). """ # Rozpoczynamy od losowej wartości guess = [random.random() for _ in xs[0]] for _ in tqdm.trange(num_steps, desc="least squares fit"): for start in range(0, len(xs), batch_size): batch_xs = xs[start:start + batch_size] batch_ys = ys[start:start + batch_size] gradient = vector_mean([ sqerror_gradient(x, y, guess) for x, y in zip(batch_xs, batch_ys) ]) guess = gradient_step(guess, gradient, -learning_rate) return guess
def main(): inputs: List[List[float]] = [[-14, -5], [13, 13], [20, 23], [-19, -11], [-9, -16], [21, 27], [-49, 15], [26, 13], [-46, 5], [-34, -1], [11, 15], [-49, 0], [-22, -16], [19, 28], [-12, -8], [-13, -19], [-41, 8], [-11, -6], [-25, -9], [-18, -3]] random.seed(12) # so you get the same results as me clusterer = KMeans(k=3) clusterer.train(inputs) means = sorted(clusterer.means) # sort for the unit test // means만 남음 print("means when k=3" + str(means)) random.seed(0) clusterer = KMeans(k=2) clusterer.train(inputs) means = sorted(clusterer.means) print("means when k=2" + str(means)) # plot from 1 up to len(inputs) clusters // k 값 선택하기 # ks = range(1, len(inputs) + 1) # errors = [squared_clustering_errors(inputs, k) for k in ks] # # plt.plot(ks, errors) # plt.xticks(ks) # plt.xlabel("k") # plt.ylabel("total squared error") # plt.title("Total Error vs. # of Clusters") # plt.show() # # plt.savefig('im/total_error_vs_num_clusters') # plt.gca().clear() # --------------------RGB 군집화--------------------- # image_path = r"girl_with_book.jpg" # import matplotlib.image as mpimg # img = mpimg.imread(image_path) / 256 # rescale to between 0 and 1 # # print(img[:1]) # # pixels = [pixel.tolist() for row in img for pixel in row] # # clusterer = KMeans(5) # clusterer.train(pixels) # # def recolor(pixel: Vector) -> Vector: # cluster = clusterer.classify(pixel) # return clusterer.means[cluster] # # new_img = [[recolor(pixel) for pixel in row] for row in img] # # plt.close() # plt.imshow(new_img) # plt.axis('off') # # plt.show() # # plt.savefig('im/recolored_girl_with_book.jpg') # plt.gca().clear() # base_cluster = bottom_up_cluster(inputs) # # print(base_cluster) # three_cluster = [get_values(cluster) # for cluster in generate_clusters(base_cluster, 3)] # # for i, cluster, marker, color in zip([1, 2, 3], # three_cluster, # ['D', 'o', '*'], # ['r', 'g', 'b']): # xs, ys = zip(*cluster) # plt.scatter(xs, ys, color=color, marker=marker) # # x, y = vector_mean(cluster) # plt.plot(x, y, marker='$' + str(i) + '$', color='black') # # plt.title("User Locations -- 3 Bottom-Up clusters, Min") # plt.xlabel("blocks east of city center") # plt.ylabel("blocks north of city center") # # plt.show() base_cluster_max = bottom_up_cluster(inputs, max) three_cluster_max = [ get_values(cluster) for cluster in generate_clusters(base_cluster_max, 3) ] for i, cluster, marker, color in zip([1, 2, 3], three_cluster_max, ['D', 'o', '*'], ['r', 'g', 'b']): xs, ys = zip(*cluster) plt.scatter(xs, ys, color=color, marker=marker) x, y = vector_mean(cluster) plt.plot(x, y, marker='$' + str(i) + '$', color='black') plt.title("User Locations -- 3 Bottom-Up clusters, Min") plt.xlabel("blocks east of city center") plt.ylabel("blocks north of city center") plt.show()
grad = [2 * error * x, 2 * error] # gradient를 사용 return grad """평균 제곱 오차( mean squared error ) : 각 데이터 포인트에서 계산된 gradient의 평균 1. 임의의 theta로 시작 2. 모든 gradient의 평균을 계산 3. theta를 2번에서 계산된 값으로 변경 4. 반복 """ from scratch.linear_algebra import vector_mean # 임의의 경사와 절편으로 시작 import random theta = [random.uniform(-1, 1), random.uniform(-1, 1)] learning_rate = 0.001 for epoch in range(5000): # 모든 gradient의 평균을 계산 grad = vector_mean([linear_gradient(x, y, theta) for x, y in inputs]) # gradient만큼 이동 theta = gradient_step(theta, grad, -learning_rate) print(epoch, theta) slope, intercept = theta assert 19.9 < slope < 20.1, "slope should be about 20" assert 4.9 < intercept < 5.1, "intercept should be about 5"
def main(): inputs: List[List[float]] = [[-14,-5],[13,13],[20,23],[-19,-11],[-9,-16],[21,27],[-49,15],[26,13],[-46,5],[-34,-1],[11,15],[-49,0],[-22,-16],[19,28],[-12,-8],[-13,-19],[-41,8],[-11,-6],[-25,-9],[-18,-3]] random.seed(12) # so you get the same results as me clusterer = KMeans(k=3) clusterer.train(inputs) means = sorted(clusterer.means) # sort for the unit test assert len(means) == 3 # Check that the means are close to what we expect. assert squared_distance(means[0], [-44, 5]) < 1 assert squared_distance(means[1], [-16, -10]) < 1 assert squared_distance(means[2], [18, 20]) < 1 random.seed(0) clusterer = KMeans(k=2) clusterer.train(inputs) means = sorted(clusterer.means) assert len(means) == 2 assert squared_distance(means[0], [-26, -5]) < 1 assert squared_distance(means[1], [18, 20]) < 1 from matplotlib import pyplot as plt def squared_clustering_errors(inputs: List[Vector], k: int) -> float: """finds the total squared error from k-means clustering the inputs""" clusterer = KMeans(k) clusterer.train(inputs) means = clusterer.means assignments = [clusterer.classify(input) for input in inputs] return sum(squared_distance(input, means[cluster]) for input, cluster in zip(inputs, assignments)) # now plot from 1 up to len(inputs) clusters ks = range(1, len(inputs) + 1) errors = [squared_clustering_errors(inputs, k) for k in ks] plt.plot(ks, errors) plt.xticks(ks) plt.xlabel("k") plt.ylabel("total squared error") plt.title("Total Error vs. # of Clusters") # plt.show() plt.savefig('im/total_error_vs_num_clusters') plt.gca().clear() image_path = r"girl_with_book.jpg" # wherever your image is import matplotlib.image as mpimg img = mpimg.imread(image_path) / 256 # rescale to between 0 and 1 # .tolist() converts a numpy array to a Python list pixels = [pixel.tolist() for row in img for pixel in row] clusterer = KMeans(5) clusterer.train(pixels) # this might take a while def recolor(pixel: Vector) -> Vector: cluster = clusterer.classify(pixel) # index of the closest cluster return clusterer.means[cluster] # mean of the closest cluster new_img = [[recolor(pixel) for pixel in row] # recolor this row of pixels for row in img] # for each row in the image plt.close() plt.imshow(new_img) plt.axis('off') # plt.show() plt.savefig('im/recolored_girl_with_book.jpg') plt.gca().clear() base_cluster = bottom_up_cluster(inputs) three_clusters = [get_values(cluster) for cluster in generate_clusters(base_cluster, 3)] # sort smallest to largest tc = sorted(three_clusters, key=len) assert len(tc) == 3 assert [len(c) for c in tc] == [2, 4, 14] assert sorted(tc[0]) == [[11, 15], [13, 13]] plt.close() for i, cluster, marker, color in zip([1, 2, 3], three_clusters, ['D','o','*'], ['r','g','b']): xs, ys = zip(*cluster) # magic unzipping trick plt.scatter(xs, ys, color=color, marker=marker) # put a number at the mean of the cluster x, y = vector_mean(cluster) plt.plot(x, y, marker='$' + str(i) + '$', color='black') plt.title("User Locations -- 3 Bottom-Up Clusters, Min") plt.xlabel("blocks east of city center") plt.ylabel("blocks north of city center") # plt.show() plt.savefig('im/bottom_up_clusters_min.png') plt.gca().clear() plt.close() base_cluster_max = bottom_up_cluster(inputs, max) three_clusters_max = [get_values(cluster) for cluster in generate_clusters(base_cluster_max, 3)] for i, cluster, marker, color in zip([1, 2, 3], three_clusters_max, ['D','o','*'], ['r','g','b']): xs, ys = zip(*cluster) # magic unzipping trick plt.scatter(xs, ys, color=color, marker=marker) # put a number at the mean of the cluster x, y = vector_mean(cluster) plt.plot(x, y, marker='$' + str(i) + '$', color='black') plt.title("User Locations -- 3 Bottom-Up Clusters, Max") plt.xlabel("blocks east of city center") plt.ylabel("blocks north of city center") plt.savefig('im/bottom_up_clusters_max.png') plt.gca().clear()
def main(): xs = range(-10, 11) actuals = [derivative(x) for x in xs] estimates = [difference_quotient(square, x, h=0.001) for x in xs] # plot to show they're basically the same import matplotlib.pyplot as plt plt.title("Actual Derivatives vs. Estimates") plt.plot(xs, actuals, 'rx', label='Actual') # red x plt.plot(xs, estimates, 'b+', label='Estimate') # blue + plt.legend(loc=9) # plt.show() plt.close() def partial_difference_quotient(f: Callable[[Vector], float], v: Vector, i: int, h: float) -> float: """Returns the i-th partial difference quotient of f at v""" w = [ v_j + (h if j == i else 0) # add h to just the ith element of v for j, v_j in enumerate(v) ] return (f(w) - f(v)) / h # "Using the Gradient" example # pick a random starting point v = [random.uniform(-10, 10) for i in range(3)] for epoch in range(1000): grad = sum_of_squares_gradient(v) # compute the gradient at v v = gradient_step(v, grad, -0.01) # take a negative gradient step print(epoch, v) assert distance(v, [0, 0, 0]) < 0.001 # v should be close to 0 # First "Using Gradient Descent to Fit Models" example from scratch.linear_algebra import vector_mean # Start with random values for slope and intercept. theta = [random.uniform(-1, 1), random.uniform(-1, 1)] learning_rate = 0.001 for epoch in range(5000): # Compute the mean of the gradients grad = vector_mean([linear_gradient(x, y, theta) for x, y in inputs]) # Take a step in that direction theta = gradient_step(theta, grad, -learning_rate) print(epoch, theta) slope, intercept = theta assert 19.9 < slope < 20.1, "slope should be about 20" assert 4.9 < intercept < 5.1, "intercept should be about 5" # Minibatch gradient descent example theta = [random.uniform(-1, 1), random.uniform(-1, 1)] for epoch in range(1000): for batch in minibatches(inputs, batch_size=20): grad = vector_mean( [linear_gradient(x, y, theta) for x, y in batch]) theta = gradient_step(theta, grad, -learning_rate) print(epoch, theta) slope, intercept = theta assert 19.9 < slope < 20.1, "slope should be about 20" assert 4.9 < intercept < 5.1, "intercept should be about 5" # Stochastic gradient descent example theta = [random.uniform(-1, 1), random.uniform(-1, 1)] for epoch in range(100): for x, y in inputs: grad = linear_gradient(x, y, theta) theta = gradient_step(theta, grad, -learning_rate) print(epoch, theta) slope, intercept = theta assert 19.9 < slope < 20.1, "slope should be about 20" assert 4.9 < intercept < 5.1, "intercept should be about 5"
def de_mean(data: List[Vector]) -> List[Vector]: """Recenters the data to have mean 0 in every dimension""" mean = vector_mean(data) return [subtract(vector, mean) for vector in data]
def main(): inputs: List[List[float]] = [[-14, -5], [13, 13], [20, 23], [-19, -11], [-9, -16], [21, 27], [-49, 15], [26, 13], [-46, 5], [-34, -1], [11, 15], [-49, 0], [-22, -16], [19, 28], [-12, -8], [-13, -19], [-41, 8], [-11, -6], [-25, -9], [-18, -3]] random.seed(12) # Dzięki temu uzyskasz taki sam wynik jak ja. clusterer = KMeans(k=3) clusterer.train(inputs) means = sorted(clusterer.means) # sortowanie dla testów jednostkowych assert len(means) == 3 # Sprawdź, czy średnie są takie, jakich oczekiwaliśmy assert squared_distance(means[0], [-44, 5]) < 1 assert squared_distance(means[1], [-16, -10]) < 1 assert squared_distance(means[2], [18, 20]) < 1 random.seed(0) clusterer = KMeans(k=2) clusterer.train(inputs) means = sorted(clusterer.means) assert len(means) == 2 assert squared_distance(means[0], [-26, -5]) < 1 assert squared_distance(means[1], [18, 20]) < 1 from matplotlib import pyplot as plt def squared_clustering_errors(inputs: List[Vector], k: int) -> float: """Określa sumę błędów podniesionych do kwadratu uzyskanych w wyniku działania algorytmu k średnich""" clusterer = KMeans(k) clusterer.train(inputs) means = clusterer.means assignments = [clusterer.classify(input) for input in inputs] return sum( squared_distance(input, means[cluster]) for input, cluster in zip(inputs, assignments)) # Wykonaj wykres dla podziału od 1 grupy do len(inputs) grup. ks = range(1, len(inputs) + 1) errors = [squared_clustering_errors(inputs, k) for k in ks] plt.plot(ks, errors) plt.xticks(ks) plt.xlabel("k") plt.ylabel("Suma kwadratow bledow") plt.title("Blad calkowity a liczba grup") plt.show() plt.savefig('im/total_error_vs_num_clusters') plt.gca().clear() image_path = r"girl_with_book.jpg" # ścieżka pliku obrazu import matplotlib.image as mpimg img = mpimg.imread( image_path ) / 256 # przeskalujmy, aby uzyskać wartości z przedziału od 0 do 1 # .tolist() konwertuje tablicę NumPy na obiekt list pixels = [pixel.tolist() for row in img for pixel in row] clusterer = KMeans(5) clusterer.train(pixels) # Operacja ta może być czasochłonna. def recolor(pixel: Vector) -> Vector: cluster = clusterer.classify(pixel) # indeks najbliższej grupy return clusterer.means[cluster] # średnia najbliższej grupy new_img = [ [recolor(pixel) for pixel in row] # Zmień kolor tego rzędu pikseli. for row in img ] # Wykonaj tę operację dla każdego wiersza obrazu. plt.close() plt.imshow(new_img) plt.axis('off') plt.show() plt.savefig('im/recolored_girl_with_book.jpg') plt.gca().clear() base_cluster = bottom_up_cluster(inputs) three_clusters = [ get_values(cluster) for cluster in generate_clusters(base_cluster, 3) ] # posortuj od najmniejszego do największego tc = sorted(three_clusters, key=len) assert len(tc) == 3 assert [len(c) for c in tc] == [2, 4, 14] assert sorted(tc[0]) == [[11, 15], [13, 13]] plt.close() for i, cluster, marker, color in zip([1, 2, 3], three_clusters, ['D', 'o', '*'], ['r', 'g', 'b']): xs, ys = zip(*cluster) # rozpakowywanie plt.scatter(xs, ys, color=color, marker=marker) # Wprowadź średnią klastra. x, y = vector_mean(cluster) plt.plot(x, y, marker='$' + str(i) + '$', color='black') plt.title("Miejsca zamieszkania (3 grupy, metoda bottom-up, minimum)") plt.xlabel("Liczba przecznic na wschod od centrum miasta ") plt.ylabel("Liczba przecznic na polnoc od centrum miasta ") plt.show() plt.savefig('im/bottom_up_clusters_min.png') plt.gca().clear() plt.close() base_cluster_max = bottom_up_cluster(inputs, max) three_clusters_max = [ get_values(cluster) for cluster in generate_clusters(base_cluster_max, 3) ] for i, cluster, marker, color in zip([1, 2, 3], three_clusters_max, ['D', 'o', '*'], ['r', 'g', 'b']): xs, ys = zip(*cluster) # rozpakowywanie plt.scatter(xs, ys, color=color, marker=marker) # Wprowadź średnią klastra. x, y = vector_mean(cluster) plt.plot(x, y, marker='$' + str(i) + '$', color='black') plt.title("Miejsca zamieszkania (3 grupy, metoda bottom-up, maksimum)") plt.xlabel("Liczba przecznic na wschod od centrum miasta ") plt.ylabel("Liczba przecznic na polnoc od centrum miasta ") plt.savefig('im/bottom_up_clusters_max.png') plt.gca().clear()
def main(): inputs: List[List[float]] = [[-14, -5], [13, 13], [20, 23], [-19, -11], [-9, -16], [21, 27], [-49, 15], [26, 13], [-46, 5], [-34, -1], [11, 15], [-49, 0], [-22, -16], [19, 28], [-12, -8], [-13, -19], [-41, 8], [-11, -6], [-25, -9], [-18, -3]] random.seed(12) # so you get the same results as me clusterer = KMeans(k=3) clusterer.train(inputs) means = sorted(clusterer.means) # sort for the unit test assert len(means) == 3 # Check that the means are close to what we expect. assert squared_distance(means[0], [-44, 5]) < 1 assert squared_distance(means[1], [-16, -10]) < 1 assert squared_distance(means[2], [18, 20]) < 1 random.seed(0) clusterer = KMeans(k=2) clusterer.train(inputs) means = sorted(clusterer.means) assert len(means) == 2 assert squared_distance(means[0], [-26, -5]) < 1 assert squared_distance(means[1], [18, 20]) < 1 from matplotlib import pyplot as plt def squared_clustering_errors(inputs: List[Vector], k: int) -> float: """finds the total squared error from k-means clustering the inputs""" clusterer = KMeans(k) clusterer.train(inputs) means = clusterer.means assignments = [clusterer.classify(input) for input in inputs] return sum( squared_distance(input, means[cluster]) for input, cluster in zip(inputs, assignments)) # now plot from 1 up to len(inputs) clusters ks = range(1, len(inputs) + 1) errors = [squared_clustering_errors(inputs, k) for k in ks] plt.plot(ks, errors) plt.xticks(ks) plt.xlabel("k") plt.ylabel("total squared error") plt.title("Total Error vs. # of Clusters") # plt.show() plt.savefig('im/total_error_vs_num_clusters') plt.gca().clear() image_path = r"girl_with_book.jpg" # wherever your image is import matplotlib.image as mpimg img = mpimg.imread(image_path) / 256 # rescale to between 0 and 1 # .tolist() converts a numpy array to a Python list pixels = [pixel.tolist() for row in img for pixel in row] clusterer = KMeans(5) clusterer.train(pixels) # this might take a while def recolor(pixel: Vector) -> Vector: cluster = clusterer.classify(pixel) # index of the closest cluster return clusterer.means[cluster] # mean of the closest cluster new_img = [ [recolor(pixel) for pixel in row] # recolor this row of pixels for row in img ] # for each row in the image plt.close() plt.imshow(new_img) plt.axis('off') # plt.show() plt.savefig('im/recolored_girl_with_book.jpg') plt.gca().clear() base_cluster = bottom_up_cluster(inputs) three_clusters = [ get_values(cluster) for cluster in generate_clusters(base_cluster, 3) ] # sort smallest to largest tc = sorted(three_clusters, key=len) assert len(tc) == 3 assert [len(c) for c in tc] == [2, 4, 14] assert sorted(tc[0]) == [[11, 15], [13, 13]] plt.close() for i, cluster, marker, color in zip([1, 2, 3], three_clusters, ['D', 'o', '*'], ['r', 'g', 'b']): xs, ys = zip(*cluster) # magic unzipping trick plt.scatter(xs, ys, color=color, marker=marker) # put a number at the mean of the cluster x, y = vector_mean(cluster) plt.plot(x, y, marker='$' + str(i) + '$', color='black') plt.title("User Locations -- 3 Bottom-Up Clusters, Min") plt.xlabel("blocks east of city center") plt.ylabel("blocks north of city center") # plt.show() plt.savefig('im/bottom_up_clusters_min.png') plt.gca().clear() plt.close() base_cluster_max = bottom_up_cluster(inputs, max) three_clusters_max = [ get_values(cluster) for cluster in generate_clusters(base_cluster_max, 3) ] for i, cluster, marker, color in zip([1, 2, 3], three_clusters_max, ['D', 'o', '*'], ['r', 'g', 'b']): xs, ys = zip(*cluster) # magic unzipping trick plt.scatter(xs, ys, color=color, marker=marker) # put a number at the mean of the cluster x, y = vector_mean(cluster) plt.plot(x, y, marker='$' + str(i) + '$', color='black') plt.title("User Locations -- 3 Bottom-Up Clusters, Max") plt.xlabel("blocks east of city center") plt.ylabel("blocks north of city center") plt.savefig('im/bottom_up_clusters_max.png') plt.gca().clear()
def main(): xs = range(-10, 11) actuals = [derivative(x) for x in xs] estimates = [difference_quotient(square, x, h=0.001) for x in xs] # plot to show they're basically the same import matplotlib.pyplot as plt plt.title("Actual Derivatives vs. Estimates") plt.plot(xs, actuals, 'rx', label='Actual') # red x plt.plot(xs, estimates, 'b+', label='Estimate') # blue + plt.legend(loc=9) # plt.show() plt.close() def partial_difference_quotient(f: Callable[[Vector], float], v: Vector, i: int, h: float) -> float: """Returns the i-th partial difference quotient of f at v""" w = [v_j + (h if j == i else 0) # add h to just the ith element of v for j, v_j in enumerate(v)] return (f(w) - f(v)) / h # "Using the Gradient" example # pick a random starting point v = [random.uniform(-10, 10) for i in range(3)] for epoch in range(1000): grad = sum_of_squares_gradient(v) # compute the gradient at v v = gradient_step(v, grad, -0.01) # take a negative gradient step print(epoch, v) assert distance(v, [0, 0, 0]) < 0.001 # v should be close to 0 # First "Using Gradient Descent to Fit Models" example from scratch.linear_algebra import vector_mean # Start with random values for slope and intercept. theta = [random.uniform(-1, 1), random.uniform(-1, 1)] learning_rate = 0.001 for epoch in range(5000): # Compute the mean of the gradients grad = vector_mean([linear_gradient(x, y, theta) for x, y in inputs]) # Take a step in that direction theta = gradient_step(theta, grad, -learning_rate) print(epoch, theta) slope, intercept = theta assert 19.9 < slope < 20.1, "slope should be about 20" assert 4.9 < intercept < 5.1, "intercept should be about 5" # Minibatch gradient descent example theta = [random.uniform(-1, 1), random.uniform(-1, 1)] for epoch in range(1000): for batch in minibatches(inputs, batch_size=20): grad = vector_mean([linear_gradient(x, y, theta) for x, y in batch]) theta = gradient_step(theta, grad, -learning_rate) print(epoch, theta) slope, intercept = theta assert 19.9 < slope < 20.1, "slope should be about 20" assert 4.9 < intercept < 5.1, "intercept should be about 5" # Stochastic gradient descent example theta = [random.uniform(-1, 1), random.uniform(-1, 1)] for epoch in range(100): for x, y in inputs: grad = linear_gradient(x, y, theta) theta = gradient_step(theta, grad, -learning_rate) print(epoch, theta) slope, intercept = theta assert 19.9 < slope < 20.1, "slope should be about 20" assert 4.9 < intercept < 5.1, "intercept should be about 5"