def scale(data_matrix):
num_rows, num_cols = shape(data_matrix)
means = [mean(get_column(data_matrix,j))
for j in range(num_cols)]
stdevs = [standard_deviation(get_column(data_matrix,j))
for j in range(num_cols)]
return means, stdevs
def main():
"""The application entry point"""
print 'EXERCISE 1A'
print '==========='
print 'This program takes a CSV file, asks you to select a row from that'
print 'file, and then computes the mean and standard deviation of the'
print 'values in that row.'
print
file_path = io.get_and_confirm_input('Enter csv file with values: ')
data = io.read_csv_file(file_path)
if not data:
raise RuntimeError('No data found in file {}'.format(file_path))
column = io.choose_from_list(
'Which column would you like to use:', data[0].keys())
if column not in data[0]:
raise RuntimeError('Invalid column {}'.format(column))
values = linked_list.LinkedList()
for each in data:
values.insert(each[column])
for each in values:
print each
print 'Mean: ', statistics.mean(values)
print 'Std Dev: ', statistics.standard_deviation(values)
def scale(data_matrix):
"""вернуть средние и стандартные отклонения для каждого столбца"""
num_rows, num_cols = shape(data_matrix)
means = [mean(get_column(data_matrix,j))
for j in range(num_cols)]
stdevs = [standard_deviation(get_column(data_matrix,j))
for j in range(num_cols)]
return means, stdevs
def normalized_data(self, data):
"""Return the given data in normalized form.
Arguments:
data(list): A list of data points
Returns:
list: Same data points, normalized.
"""
mean = statistics.mean(data)
stddev = statistics.standard_deviation(data)
return [(each - mean)/stddev for each in data]
def get_mean(self):
return statistics.mean(self.score_list)
def least_squares_fit(x, y):
"""при заданных обучающих значениях x и y,
найти значения alpha и beta на основе МНК"""
beta = correlation(x, y) * standard_deviation(y) / standard_deviation(x)
alpha = mean(y) - beta * mean(x)
return alpha, beta
def least_squares_fit(x, y):
"""given training values for x and y,
find the least-squares values of alpha and beta"""
beta = correlation(x, y) * standard_deviation(y) / standard_deviation(x)
alpha = mean(y) - beta * mean(x)
return alpha, beta
def test_should_correctly_compute_the_mean(self):
self.assertAlmostEqual(5.0, statistics.mean(range(1, 10)))
def test_should_return_value_for_single_value(self):
self.assertEqual(12, statistics.mean([12]))
for location, actual_language in cities:
other_cities = [other_city
for other_city in cities
if other_city != (location, actual_language)]
predicted_language = knn_classify(k, other_cities, location)
if predicted_language == actual_language:
num_correct += 1
print(k, "сосед(а,ей):", num_correct, "правильных из", len(cities))
dimensions = range(1, 101, 5)
avg_distances = []
min_distances = []
random.seed(0)
for dim in dimensions:
distances = random_distances(dim, 10000) # 10000 случайных пар
avg_distances.append(mean(distances)) # отследить средние расстояния
min_distances.append(min(distances)) # отследить минимальные расстояния
print(dim, min(distances), mean(distances), min(distances) / mean(distances))
# In[ ]:
