def lab1_test_ex_2(dummy_divisible_by_3):
res = dummy_divisible_by_3.take(10) + dummy_divisible_by_3.top(10)
f_10 = dummy_divisible_by_3.take(10)
Test.assertEqualsHashed(
res, 'f560a8e93e904ba6eafad0c41ff0ad52e8db37ee',
'Incorrect RDD: [{}, ...]'.format(list_continious(f_10)),
'Correct RDD: [{}, ...]'.format(list_continious(f_10)))
def lab4_test_ex_8(average, RMSE):
Test.assertEqualsHashed(
average, '48da600e257d511cd9a7db7ce4fa34ae6b92748e',
'incorrect average purchase (expected 3.8254751809)',
'Test 8.1 is successful')
Test.assertEqualsHashed(RMSE, '215eafc55a1caa2db0dd959fcba648e27d270cc9',
'incorrect RMSE (expected 4.99122318964)',
'Test 8.2 is successful')
def run_tests(): Test.assertEquals(test_year(1945, df), [u'Mary', u'Linda', u'Barbara', u'Patricia', u'Carol'], 'incorrect top 5 names for 1945') Test.assertEquals(test_year(1970, df), [u'Jennifer', u'Lisa', u'Kimberly', u'Michelle', u'Amy'], 'incorrect top 5 names for 1970') Test.assertEquals(test_year(1987, df), [u'Jessica', u'Ashley', u'Amanda', u'Jennifer', u'Sarah'], 'incorrect top 5 names for 1987') Test.assertTrue(len(test_year(1945, df)) <= 5, 'list not limited to 5 names') Test.assertTrue(u'James' not in test_year(1945, df), 'male names not filtered') Test.assertTrue(test_year(1945, df) != [u'Linda', u'Linda', u'Linda', u'Linda', u'Mary'], 'year not filtered') Test.assertEqualsHashed(test_year(1880, df), "2038e2c0bb0b741797a47837c0f94dbf24123447", "incorrect top 5 names for 1880")
def lab4_test_ex_4_3(purchases):
Test.assertEqualsHashed(
[purchases.take(5), purchases.count()],
'27475424fbfde8a2a48b480a5db01eb3f9884182',
#'c1fdc61ea8e59eec85a99cc2c017831baa4f4051',
'Incorrect purchases RDD: [{}, ...]'.format(
list_continious(purchases.take(5))),
'Correct purchases RDD: [{}, ...]'.format(
list_continious(purchases.take(5))))
def lab1_test_ex_4(letters, occurrence):
res = letters.collect()
Test.assertEqualsHashed(res, '19275f3ffa39938f61d208d6b310835fb18b759f',
'Incorrect RDD: {}'.format(res),
'Correct RDD: {}'.format(res))
Test.assertEqualsHashed(occurrence,
'22d71673a52391bd1724694ce8a2ec0238356522',
'Incorrect dict: {}'.format(occurrence),
'Correct dict: {}'.format(occurrence))
def lab1_test_ex_6(number_pairs, number_duplicates):
res1 = number_pairs.collect()
Test.assertEqualsHashed(res1, '19e2885cbed30b9b2cfc220cf979b1d137e11f52',
'Incorrect RDD: {}'.format(res1),
'Correct RDD: {}'.format(res1))
res2 = number_duplicates.collect()
Test.assertEqualsHashed(res2, '84df916b883f187ed27a3109cf14bb4bd80e78e9',
'Incorrect RDD: {}'.format(res2),
'Correct RDD: {}'.format(res2))
def lab3_test_ex_7_5(test_error_lr, test_error_svm):
Test.assertEqualsHashed(test_error_lr <= 0.23,
'88b33e4e12f75ac8bf792aebde41f1a090f3a612',
'Incorrect LogisticRegression err calculation',
'Correct LogisticRegression err calculation')
Test.assertEqualsHashed(test_error_svm <= 0.23,
'88b33e4e12f75ac8bf792aebde41f1a090f3a612',
'Incorrect SVMWithSGD err calculation',
'Correct SVMWithSGD err calculation')
def lab1_test_ex_7(inventory_diff, inventory_diff_sorted):
res1 = inventory_diff.collect()
Test.assertEqualsHashed(res1, '3af93b5e352a178963b6f6d72986edfc5a20aa6c',
'Incorrect RDD: {}'.format(res1),
'Correct RDD: {}'.format(res1))
res2 = inventory_diff_sorted.collect()
Test.assertEqualsHashed(res2, '89066489ead47cae2fa3737e8c4a82bc3e9afbd6',
'Incorrect RDD: {}'.format(res2),
'Correct RDD: {}'.format(res2))
def lab3_test_ex_5_1(squared_error, example_RMSE):
Test.assertEqualsHashed(squared_error(3, 1),
'1b6453892473a467d07372d45eb05abc2031647a',
'Incorrect squared_error function',
'Correct squared_error function')
Test.assertEqualsHashed(example_RMSE,
'4b322e37f07576b9230316f90b84285b5d096941',
'Incorrect example_error: {}'.format(example_RMSE),
'Correct example_error: {}'.format(example_RMSE))
def lab2_test_ex_1(logs):
c = logs.count()
t = logs.top(2)
Test.assertEqualsHashed(c, 'd779e44c393784ee42c0baf60e5f787f2ab64d81',
'Incorrect logs count: {}'.format(c),
'Correct logs count: {}'.format(c))
Test.assertEqualsHashed(
t, '80b7732e143c2f3f867e9fdd0118c2ad6e47c141',
'Incorrect logs: [{}, ...]'.format(list_continious(logs.take(2))),
'Correct logs: [{}, ...]'.format(list_continious(logs.take(2))))
def lab3_test_ex_7_1(parsed_groups, train_data, test_data):
Test.assertEqualsHashed(
parsed_groups.map(lambda lp: lp.label).sum(),
'0ce7925bf636cbafa9005ce2d9673bc31b8122a6', 'Incorect splitting',
'Correct splitting')
Test.assertEqualsHashed(
train_data.map(lambda lp: lp.label).sum() +
test_data.map(lambda lp: lp.label).sum(),
'0ce7925bf636cbafa9005ce2d9673bc31b8122a6', 'Incorect splitting',
'Correct splitting')
def lab3_test_ex_5_3(val_RMSE, best_RMSE):
Test.assertEqualsHashed(
abs(val_RMSE - 1.52408180718) < 1,
'88b33e4e12f75ac8bf792aebde41f1a090f3a612',
'Incorrect val_RMSE: {}'.format(val_RMSE),
'Correct val_RMSE: {}'.format(val_RMSE))
Test.assertEqualsHashed(
abs(best_RMSE - 1.524081788) < 1,
'88b33e4e12f75ac8bf792aebde41f1a090f3a612',
'Incorrect best_RMSE: {}'.format(best_RMSE),
'Correct best_RMSE: {}'.format(best_RMSE))
def lab4_test_ex_7(RMSE, predictions):
Test.assertTrue(
abs(RMSE - 4.72051562103) < 0.5,
'incorrect RMSE value (expected about 4.721)', 'Test 7.1 - success')
Test.assertEqualsHashed(
predictions.take(3)[1], '11ec7603d09fbc0af0517cacd4d162f4a9e18196',
'incorrect first 3 elements of the predictions', 'Test 7.2 - success')
Test.assertEqualsHashed(
abs(predictions.take(5)[4][2] - 5.048388885082981) < 0.2,
'88b33e4e12f75ac8bf792aebde41f1a090f3a612',
'incorrect prediction for the element in predictions',
'Test 7.3 - success')
def lab4_test_ex_4_1(indexed_buyers, indexed_products):
l1 = len(indexed_buyers)
Test.assertEqualsHashed(
l1, '0029723da11a640ffd2eec846a9a2cca6285831b',
'Incorrect length of indexed_buyers: {}'.format(l1),
'Correct length of indexed_buyers: {}'.format(l1))
l2 = len(indexed_products)
Test.assertEqualsHashed(
l2, '2e0ab5b38ac3a139b7527efc5eec2118105b82b0',
'Incorrect length of indexed_buyers: {}'.format(l2),
'Correct length of indexed_buyers: {}'.format(l2))
def lab4_test_ex_3(recommended_products):
l = len(recommended_products)
Test.assertEqualsHashed(l, '91032ad7bbcb6cf72875e8e8207dcfba80173f7c',
'Incorrect number of products: {}'.format(l),
'Correct number of products: {}'.format(l))
Test.assertEqualsHashed(
recommended_products,
'389979fae5f36cafbd562ea5c80f5660d42eaefb',
#'d5ee60603688f50e1d4bbf18e174866db11c1b99',
'Incorrect products: [{}, ...]'.format(
list_continious(recommended_products)),
'Correct products: [{}, ...]'.format(
list_continious(recommended_products[0:3])))
def lab4_test_ex_1(get_counts_and_averages):
data = [(1, (1, 2, 3, 4)), (100, (10.0, 20.0, 30.0)), (110, xrange(20))]
expectations = [
'7650c6f17f08af462b87700b3d78f4007675a7db',
'878cc669276bfb82d2953b2e50896b7e1e1e1c4f',
'8d7a82af2322875247f75cac0f18ff522101b9c6'
]
for (args, expectation) in zip(data, expectations):
result = get_counts_and_averages(args)
Test.assertEqualsHashed(result, expectation,
'Test failed for: {}'.format(args),
'{} -> {}'.format(args, result))
def lab3_test_ex_2_2(parsed_points, shifted_parsed_points):
old_features = parsed_points.first().features
new_features = shifted_parsed_points.first().features
diff_features = old_features - new_features
new_min_rating = shifted_parsed_points.map(lambda lp: lp.label).min()
new_max_rating = shifted_parsed_points.map(lambda lp: lp.label).max()
new_rating_range = new_max_rating - new_min_rating
Test.assertEqualsHashed(diff_features,
'0bf31a85e53f1ce22604702e55bbf7f41ebde965',
'New features are not calculated correctly',
'New features calculated correctly')
Test.assertEqualsHashed(new_rating_range,
'2ce6ddc84d93a3a1dcd84238cd67260bd7272e08',
'New year range is not calculated correctly',
'New year range calculated correctly')
def lab3_test_ex_4_1(weights, intercept):
expected_intercept = 1.00003687092
expected_weights = [
0.000250792702944, 9.87942310023e-06, 1.22220831068e-05,
0.000221312646545, 1.58457070761e-06, 0.00128775449573,
0.00488322878768, 3.66514390106e-05, 0.000117928277594,
1.81713979186e-05, 0.000399983541013
]
Test.assertEqualsHashed(
abs(intercept - expected_intercept) < 1,
'88b33e4e12f75ac8bf792aebde41f1a090f3a612',
'Incorrect intercept: {}'.format(intercept),
'Correct intercept: {}'.format(intercept))
Test.assertEqualsHashed(
abs(weights[0] - expected_weights[0]) < 1,
'88b33e4e12f75ac8bf792aebde41f1a090f3a612',
'Incorrect weights: {}'.format(weights),
'Correct weights: {}'.format(weights))
def run_tests():
Test.assertEquals(test_year(1945, df),
[u'Mary', u'Linda', u'Barbara', u'Patricia', u'Carol'],
'incorrect top 5 names for 1945')
Test.assertEquals(test_year(1970, df),
[u'Jennifer', u'Lisa', u'Kimberly', u'Michelle', u'Amy'],
'incorrect top 5 names for 1970')
Test.assertEquals(test_year(
1987, df), [u'Jessica', u'Ashley', u'Amanda', u'Jennifer', u'Sarah'],
'incorrect top 5 names for 1987')
Test.assertTrue(
len(test_year(1945, df)) <= 5, 'list not limited to 5 names')
Test.assertTrue(u'James' not in test_year(1945, df),
'male names not filtered')
Test.assertTrue(
test_year(1945, df) !=
[u'Linda', u'Linda', u'Linda', u'Linda', u'Mary'], 'year not filtered')
Test.assertEqualsHashed(test_year(1880, df),
"2038e2c0bb0b741797a47837c0f94dbf24123447",
"incorrect top 5 names for 1880")
def lab2_test_ex_2(csa, csmin, csmax):
Test.assertEqualsHashed(csa, '3b37b833000b5646f0ea8606a5e980b5728c77c4',
'Incorrect avg size: {}'.format(csa),
'Correct avg size: {}'.format(csa))
Test.assertEqualsHashed(csmin, 'b6589fc6ab0dc82cf12099d1c2d40ab994e8410c',
'Incorrect min size: {}'.format(csmin),
'Correct min size: {}'.format(csmin))
Test.assertEqualsHashed(csmax, '23ecf47a03f192561239cc7da9ea3e8755c8c0ee',
'Incorrect max size: {}'.format(csmax),
'Correct max size: {}'.format(csmax))
def lab1_test_ex_3(dummy_less_than_50, dummy_top_5, dummy_product):
res = dummy_less_than_50.collect()
Test.assertEqualsHashed(res, '3e4e1750c95be2c366128d69d78aea2afde114a8',
'Incorrect RDD: {}'.format(res),
'Correct RDD: {}'.format(res))
Test.assertEqualsHashed(dummy_top_5,
'8ff5b2b55bc143e048bf78182ec3194f1e49e0c7',
'Incorrect RDD: {}'.format(dummy_top_5),
'Correct RDD: {}'.format(dummy_top_5))
Test.assertEqualsHashed(dummy_product,
'cb78c76bd7a7cfe8feb17ad7a4e1166dcfbbb7d3',
'Incorrect product: {}'.format(dummy_product),
'Correct product: {}'.format(dummy_product))
def lab3_test_ex_2_1(min_rating, max_rating, rating_range):
Test.assertEqualsHashed(min_rating,
'bdc1408a91f161dab5a9893d23db3c7095200e1d',
'Incorrect min rating: {}'.format(min_rating),
'Correct min rating: {}'.format(min_rating))
Test.assertEqualsHashed(max_rating,
'b85ab32eaa572c8016edf68011078dceed8149e5',
'Incorrect max rating: {}'.format(max_rating),
'Correct max rating: {}'.format(max_rating))
Test.assertEqualsHashed(rating_range,
'2ce6ddc84d93a3a1dcd84238cd67260bd7272e08',
'Incorrect rating range: {}'.format(rating_range),
'Correct rating range: {}'.format(rating_range))
def lab3_test_ex_6_2(train_data, test_data, parsed_intervals):
Test.assertEqualsHashed(
train_data.map(lambda lp: lp.label).sum(),
'95790ce05be9850d7bb5d2c4e8f8d2cb9c3476d6', 'Incorect splitting',
'Correct splitting')
Test.assertEqualsHashed(
test_data.map(lambda lp: lp.label).sum(),
'dd10ec4543eef62a4eff4ce4f324ca036df08b4c', 'Incorect splitting',
'Correct splitting')
Test.assertEqualsHashed(
np.allclose(
parsed_intervals.map(lambda lp: lp.label).sum(),
train_data.map(lambda lp: lp.label).sum() +
test_data.map(lambda lp: lp.label).sum()),
'88b33e4e12f75ac8bf792aebde41f1a090f3a612', 'Incorect splitting',
'Correct splitting')
def lab1_test_ex_5(pairs, flat_pairs, flattened_pairs):
res1 = pairs.take(5) + pairs.top(5)
Test.assertEqualsHashed(
res1, 'fb52be8957a9bdf4eaf329b26cdb707cdec41135',
'Incorrect RDD: [{}, ...]'.format(list_continious(res1)),
'Correct RDD: [{}, ...]'.format(list_continious(res1)))
res2 = flat_pairs.take(10) + flat_pairs.top(10)
Test.assertEqualsHashed(
res2, 'a0e5a552e17d1c96511d392768c197e7318ec479',
'Incorrect RDD: [{}, ...]'.format(list_continious(res2)),
'Correct RDD: [{}, ...]'.format(list_continious(res2)))
res3 = flattened_pairs.take(10) + flattened_pairs.top(10)
Test.assertEqualsHashed(
res3, 'a0e5a552e17d1c96511d392768c197e7318ec479',
'Incorrect RDD: [{}, ...]'.format(list_continious(res3)),
'Correct RDD: [{}, ...]'.format(list_continious(res3)))
def lab3_test_ex_1(first_point_label, first_point_features):
Test.assertEqualsHashed(
len(first_point_features), '17ba0791499db908433b80f37c5fbc89b870084b',
'Incorrect number of features: {}'.format(len(first_point_features)),
'Correct number of features: {}'.format(len(first_point_features)))
Test.assertEqualsHashed(first_point_label,
'2ce6ddc84d93a3a1dcd84238cd67260bd7272e08',
'Incorrect label: {}'.format(first_point_label),
'Correct label: {}'.format(first_point_label))
expected_x0 = [
7.0, 0.27, 0.36, 20.7, 0.045, 45.0, 170.0, 1.001, 3.0, 0.45, 8.8
]
Test.assertEqualsHashed(
(first_point_features - expected_x0),
'0bf31a85e53f1ce22604702e55bbf7f41ebde965',
'Incorrect features: {}'.format(first_point_features),
'Correct features: {}'.format(first_point_features))
def lab4_test_ex_2(grouped_purchases, average_purchases):
gpc = grouped_purchases.count()
Test.assertEqualsHashed(
gpc, '2e0ab5b38ac3a139b7527efc5eec2118105b82b0',
'Incorrect length of "grouped_purchases": {}'.format(gpc),
'Length of `grouped_purchases` is {}'.format(gpc))
apc = average_purchases.count()
Test.assertEqualsHashed(
apc, '2e0ab5b38ac3a139b7527efc5eec2118105b82b0',
'Incorrect length of "average_purchases": {}'.format(apc),
'Length of `average_purchases` is {}'.format(apc))
ap = average_purchases.takeOrdered(3)
Test.assertEqualsHashed(
ap,
'b66b7ed8a7d8127b31625f4d0ce631bb4cc8e232',
#'b0eb8bf0055def9cb27b14faea14e9873afe3d52',
'Incorrect `average_purchases`: {}'.format(ap),
'Correct `average_purchases`: {}'.format(ap))
def lab3_test_ex_3(n_partitions, train_data, val_data, test_data):
sf2 = train_data.map(lambda lp: lp.features[2]).sum()
sf3 = val_data.map(lambda lp: lp.features[3]).sum()
sf4 = test_data.map(lambda lp: lp.features[4]).sum()
sums = [sf2, sf3, sf4]
n_total = train_data.count() + val_data.count() + test_data.count()
Test.assertEqualsHashed(n_total,
'6f62570437644d4721b266a162d20cc35889917f',
'Unexpected Train, Val, Test dataset sizes',
'Train, Val, Test sizes are ok')
Test.assertEqualsHashed(sums, '8b4a1f9f2301bd4396fe196fb3cb62dda4b70b0d',
'Train, Val, Test have unexpected values',
'Train, Val, Test are ok')
Test.assertEqualsHashed(
n_partitions, '9f28346a7d38b31687c9d21909b6318da391f569',
'Wrong number of partitions: {}'.format(n_partitions),
'Correct number of partitions: {}'.format(n_partitions))
# In[2]:
# TODO: Replace <FILL IN> with appropriate code
# Manually calculate your answer and represent the vector as a list of integers values.
# For example, [2, 4, 8].
x = [3, -6, 0]
y = [4, 8, 16]
# In[3]:
# TEST Scalar multiplication: vectors (1a)
# Import test library
from test_helper import Test
Test.assertEqualsHashed(x, "e460f5b87531a2b60e0f55c31b2e49914f779981", "incorrect value for vector x")
Test.assertEqualsHashed(y, "e2d37ff11427dbac7f833a5a7039c0de5a740b1e", "incorrect value for vector y")
# #### ** (1b) Element-wise multiplication: vectors **
# #### In this exercise, you will calculate the element-wise multiplication of two vectors by hand and enter the result in the code cell below. You'll later see that element-wise multiplication is the default method when two NumPy arrays are multiplied together. Note we won't be performing element-wise multiplication in future labs, but we are introducing it here to distinguish it from other vector operators, and to because it is a common operations in NumPy, as we will discuss in Part (2b).
# #### The element-wise calculation is as follows: $$ \mathbf{x} \odot \mathbf{y} = \begin{bmatrix} x_1 y_1 \\\ x_2 y_2 \\\ \vdots \\\ x_n y_n \end{bmatrix} $$
# #### Calculate the value of $ \mathbf{z} $: $$ \mathbf{z} = \begin{bmatrix} 1 \\\ 2 \\\ 3 \end{bmatrix} \odot \begin{bmatrix} 4 \\\ 5 \\\ 6 \end{bmatrix} $$
# In[4]:
# TODO: Replace <FILL IN> with appropriate code
# Manually calculate your answer and represent the vector as a list of integers values.
z = [4, 10, 18]
sampleDataRDD = sc.parallelize([sampleOne, sampleTwo, sampleThree])
sampleOHEDictManual = {}
sampleOHEDictManual[(0,'bear')] = 0
sampleOHEDictManual[(0,'cat')] = 1
sampleOHEDictManual[(0,'mouse')] = 2
sampleOHEDictManual[(1,'black')] = 3
sampleOHEDictManual[(1,'tabby')] = 4
sampleOHEDictManual[(2,'mouse')] = 5
sampleOHEDictManual[(2,'salmon')]= 6
# TEST One-hot-encoding
from test_helper import Test
Test.assertEqualsHashed(sampleOHEDictManual[(0,'bear')],
'b6589fc6ab0dc82cf12099d1c2d40ab994e8410c',
"incorrect value for sampleOHEDictManual[(0,'bear')]")
Test.assertEqualsHashed(sampleOHEDictManual[(0,'cat')],
'356a192b7913b04c54574d18c28d46e6395428ab',
"incorrect value for sampleOHEDictManual[(0,'cat')]")
Test.assertEqualsHashed(sampleOHEDictManual[(0,'mouse')],
'da4b9237bacccdf19c0760cab7aec4a8359010b0',
"incorrect value for sampleOHEDictManual[(0,'mouse')]")
Test.assertEqualsHashed(sampleOHEDictManual[(1,'black')],
'77de68daecd823babbb58edb1c8e14d7106e83bb',
"incorrect value for sampleOHEDictManual[(1,'black')]")
Test.assertEqualsHashed(sampleOHEDictManual[(1,'tabby')],
'1b6453892473a467d07372d45eb05abc2031647a',
"incorrect value for sampleOHEDictManual[(1,'tabby')]")
Test.assertEqualsHashed(sampleOHEDictManual[(2,'mouse')],
'ac3478d69a3c81fa62e60f5c3696165a4e5e6ac4',
# ### ** Part 2: Check class testing library **
# #### ** (2a) Compare with hash **
# In[ ]:
# TEST Compare with hash (2a)
# Check our testing library/package
# This should print '1 test passed.' on two lines
from test_helper import Test
twelve = 12
Test.assertEquals(twelve, 12, 'twelve should equal 12')
Test.assertEqualsHashed(twelve, '7b52009b64fd0a2a49e6d8a939753077792b0554',
'twelve, once hashed, should equal the hashed value of 12')
# #### ** (2b) Compare lists **
# In[ ]:
# TEST Compare lists (2b)
# This should print '1 test passed.'
unsortedList = [(5, 'b'), (5, 'a'), (4, 'c'), (3, 'a')]
Test.assertEquals(sorted(unsortedList), [(3, 'a'), (4, 'c'), (5, 'a'), (5, 'b')],
'unsortedList does not sort properly')
# ### ** Part 3: Check plotting **
from test_helper import Test
x = 1
y = 2
Test.assertEquals(x, 1)
Test.assertEquals(x + 1, 2)
Test.assertEquals(y, 1, "y is incorrect")
Test.assertEqualsHashed(x, '356a192b7913b04c54574d18c28d46e6395428ab',
'this is a test')
Test.printStats()
Test.setFailFast()
Test.setPrivateMode()
Test.assertEquals(y, 1, "y is incorrect")
# Transparent Tests
from test_helper import Test
def test_year(year, df):
return [row.firstName for row in top_female_names_for_year(year, 5, df).collect()]
# COMMAND ----------
def run_tests():
Test.assertEquals(test_year(1945, df), [u'Mary', u'Linda', u'Barbara', u'Patricia', u'Carol'], 'incorrect top 5 names for 1945')
Test.assertEquals(test_year(1970, df), [u'Jennifer', u'Lisa', u'Kimberly', u'Michelle', u'Amy'], 'incorrect top 5 names for 1970')
Test.assertEquals(test_year(1987, df), [u'Jessica', u'Ashley', u'Amanda', u'Jennifer', u'Sarah'], 'incorrect top 5 names for 1987')
Test.assertTrue(len(test_year(1945, df)) <= 5, 'list not limited to 5 names')
Test.assertTrue(u'James' not in test_year(1945, df), 'male names not filtered')
Test.assertTrue(test_year(1945, df) != [u'Linda', u'Linda', u'Linda', u'Linda', u'Mary'], 'year not filtered')
Test.assertEqualsHashed(test_year(1880, df), "2038e2c0bb0b741797a47837c0f94dbf24123447", "incorrect top 5 names for 1880")
run_tests()
# COMMAND ----------
# MAGIC %md
# COMMAND ----------
# MAGIC %md
# MAGIC ## Solution
# MAGIC
# MAGIC If you're stuck, and you're really not sure how to proceed, feel free to check out the solution. You'll find it in the same folder as the lab.
# COMMAND ----------
# ### ** Part 2: Check class testing library **
# #### ** (2a) Compare with hash **
# In[4]:
# TEST Compare with hash (2a)
# Check our testing library/package
# This should print '1 test passed.' on two lines
from test_helper import Test
twelve = 12
Test.assertEquals(twelve, 12, 'twelve should equal 12')
Test.assertEqualsHashed(
twelve, '7b52009b64fd0a2a49e6d8a939753077792b0554',
'twelve, once hashed, should equal the hashed value of 12')
# #### ** (2b) Compare lists **
# In[5]:
# TEST Compare lists (2b)
# This should print '1 test passed.'
unsortedList = [(5, 'b'), (5, 'a'), (4, 'c'), (3, 'a')]
Test.assertEquals(sorted(unsortedList), [(3, 'a'), (4, 'c'), (5, 'a'),
(5, 'b')],
'unsortedList does not sort properly')
# ### ** Part 3: Check plotting **
# In[1]:
# TODO: Replace <FILL IN> with appropriate code
# Manually calculate your answer and represent the vector as a list of integers values.
# For example, [2, 4, 8].
x = [3, -6, 0]
y = [4, 8, 16]
# In[2]:
# TEST Scalar multiplication: vectors (1a)
# Import test library
from test_helper import Test
Test.assertEqualsHashed(x, 'e460f5b87531a2b60e0f55c31b2e49914f779981',
'incorrect value for vector x')
Test.assertEqualsHashed(y, 'e2d37ff11427dbac7f833a5a7039c0de5a740b1e',
'incorrect value for vector y')
# #### ** (1b) Element-wise multiplication: vectors **
# #### In this exercise, you will calculate the element-wise multiplication of two vectors by hand and enter the result in the code cell below. You'll later see that element-wise multiplication is the default method when two NumPy arrays are multiplied together. Note we won't be performing element-wise multiplication in future labs, but we are introducing it here to distinguish it from other vector operators, and to because it is a common operations in NumPy, as we will discuss in Part (2b).
# #### The element-wise calculation is as follows: $$ \mathbf{x} \odot \mathbf{y} = \begin{bmatrix} x_1 y_1 \\\ x_2 y_2 \\\ \vdots \\\ x_n y_n \end{bmatrix} $$
# #### Calculate the value of $ \mathbf{z} $: $$ \mathbf{z} = \begin{bmatrix} 1 \\\ 2 \\\ 3 \end{bmatrix} \odot \begin{bmatrix} 4 \\\ 5 \\\ 6 \end{bmatrix} $$
# In[3]:
# TODO: Replace <FILL IN> with appropriate code
# Manually calculate your answer and represent the vector as a list of integers values.
z = [4, 10, 18]
from test_helper import Test x = 1 y = 2 Test.assertEquals(x, 1) Test.assertEquals(x + 1, 2) Test.assertEquals(y, 1, "y is incorrect") Test.assertEqualsHashed(x,'356a192b7913b04c54574d18c28d46e6395428ab', 'this is a test') Test.printStats() Test.setFailFast() Test.setPrivateMode() Test.assertEquals(y, 1, "y is incorrect")
