From 34cac78424219f2ec3e5b136979a7e57852dbcaf Mon Sep 17 00:00:00 2001 From: WilliamStarling <63762012+WilliamStarling@users.noreply.github.com> Date: Sun, 28 Jul 2024 00:15:28 -0500 Subject: [PATCH 1/6] Update Part1_TensorFlow.ipynb updated the google colab link to link to my fork instead of the original. --- lab1/Part1_TensorFlow.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lab1/Part1_TensorFlow.ipynb b/lab1/Part1_TensorFlow.ipynb index 25e4894e..4c85e025 100644 --- a/lab1/Part1_TensorFlow.ipynb +++ b/lab1/Part1_TensorFlow.ipynb @@ -10,7 +10,7 @@ " \n", " \n", " Visit MIT Deep Learning\n", - " \n", + " \n", " Run in Google Colab\n", " \n", " View Source on GitHub\n", @@ -695,4 +695,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} From df5840ce6a887ad5a4613639a7a2f2d586672507 Mon Sep 17 00:00:00 2001 From: WilliamStarling <63762012+WilliamStarling@users.noreply.github.com> Date: Sun, 28 Jul 2024 00:20:08 -0500 Subject: [PATCH 2/6] finished TO DO segments in lab 1 part 1 section 1.1 --- lab1/Part1_TensorFlow.ipynb | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/lab1/Part1_TensorFlow.ipynb b/lab1/Part1_TensorFlow.ipynb index 4c85e025..8e22ab54 100644 --- a/lab1/Part1_TensorFlow.ipynb +++ b/lab1/Part1_TensorFlow.ipynb @@ -149,10 +149,11 @@ "### Defining higher-order Tensors ###\n", "\n", "'''TODO: Define a 2-d Tensor'''\n", - "matrix = # TODO\n", + "matrix = tf.constant([[1, 4, 3, 8], [2, 6, 12, 24]], tf.float64)\n", "\n", "assert isinstance(matrix, tf.Tensor), \"matrix must be a tf Tensor object\"\n", - "assert tf.rank(matrix).numpy() == 2" + "assert tf.rank(matrix).numpy() == 2\n", + "print(\"finished running\")" ] }, { @@ -166,7 +167,7 @@ "'''TODO: Define a 4-d Tensor.'''\n", "# Use tf.zeros to initialize a 4-d Tensor of zeros with size 10 x 256 x 256 x 3.\n", "# You can think of this as 10 images where each image is RGB 256 x 256.\n", - "images = # TODO\n", + "images = tf.zeros([10, 256, 256, 3], tf.int32)\n", "\n", "assert isinstance(images, tf.Tensor), \"matrix must be a tf Tensor object\"\n", "assert tf.rank(images).numpy() == 4, \"matrix must be of rank 4\"\n", @@ -695,4 +696,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file From 26de50db398544edccc53cdadcfb149d6af6926b Mon Sep 17 00:00:00 2001 From: WilliamStarling <63762012+WilliamStarling@users.noreply.github.com> Date: Sun, 28 Jul 2024 00:21:50 -0500 Subject: [PATCH 3/6] giving permissions to school gmail. --- lab1/Part1_TensorFlow.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lab1/Part1_TensorFlow.ipynb b/lab1/Part1_TensorFlow.ipynb index 8e22ab54..37440d87 100644 --- a/lab1/Part1_TensorFlow.ipynb +++ b/lab1/Part1_TensorFlow.ipynb @@ -153,7 +153,7 @@ "\n", "assert isinstance(matrix, tf.Tensor), \"matrix must be a tf Tensor object\"\n", "assert tf.rank(matrix).numpy() == 2\n", - "print(\"finished running\")" + "print(\"Finished running\")" ] }, { From ae395974eb35ea28a8350cbb2a83e144863888d4 Mon Sep 17 00:00:00 2001 From: WilliamStarling <63762012+WilliamStarling@users.noreply.github.com> Date: Sun, 28 Jul 2024 22:52:17 -0500 Subject: [PATCH 4/6] Finished Pt1 of Lab1 --- lab1/Part1_TensorFlow.ipynb | 455 +++++++++++++++++++++++++++++------- 1 file changed, 369 insertions(+), 86 deletions(-) diff --git a/lab1/Part1_TensorFlow.ipynb b/lab1/Part1_TensorFlow.ipynb index 37440d87..5c50a72a 100644 --- a/lab1/Part1_TensorFlow.ipynb +++ b/lab1/Part1_TensorFlow.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "id": "3eI6DUic-6jo" }, @@ -59,11 +59,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "LkaimNJfYZ2w" - }, - "outputs": [], + "execution_count": 5, + "metadata": { + "id": "LkaimNJfYZ2w", + "outputId": "d0dbc631-c28e-4e44-94c0-3e44fa4c8890", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/2.1 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.2/2.1 MB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/2.1 MB\u001b[0m \u001b[31m17.5 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.1/2.1 MB\u001b[0m \u001b[31m20.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for mitdeeplearning (setup.py) ... \u001b[?25l\u001b[?25hdone\n" + ] + } + ], "source": [ "import tensorflow as tf\n", "\n", @@ -92,11 +106,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "tFxztZQInlAB" - }, - "outputs": [], + "execution_count": 6, + "metadata": { + "id": "tFxztZQInlAB", + "outputId": "748ac293-e27f-413e-e740-fc8ff8310919", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "`sport` is a 0-d Tensor\n", + "`number` is a 0-d Tensor\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], "source": [ "sport = tf.constant(\"Tennis\", tf.string)\n", "number = tf.constant(1.41421356237, tf.float64)\n", @@ -116,11 +151,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "oaHXABe8oPcO" - }, - "outputs": [], + "execution_count": 7, + "metadata": { + "id": "oaHXABe8oPcO", + "outputId": "a6dd1ee0-e294-435f-beb9-14b2eb16f708", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "`sports` is a 1-d Tensor with shape: [2]\n", + "`numbers` is a 1-d Tensor with shape: [3]\n" + ] + } + ], "source": [ "sports = tf.constant([\"Tennis\", \"Basketball\"], tf.string)\n", "numbers = tf.constant([3.141592, 1.414213, 2.71821], tf.float64)\n", @@ -140,11 +188,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "tFeBBe1IouS3" - }, - "outputs": [], + "execution_count": 8, + "metadata": { + "id": "tFeBBe1IouS3", + "outputId": "e6986fe1-18aa-476f-8fa7-3e456679a9fc", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Finished running\n" + ] + } + ], "source": [ "### Defining higher-order Tensors ###\n", "\n", @@ -158,7 +218,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "id": "Zv1fTn_Ya_cz" }, @@ -185,11 +245,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "FhaufyObuLEG" - }, - "outputs": [], + "execution_count": 10, + "metadata": { + "id": "FhaufyObuLEG", + "outputId": "132edaf3-3832-4b7e-c317-ff7401edfcc6", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "`row_vector`: [ 2. 6. 12. 24.]\n", + "`column_vector`: [4. 6.]\n", + "`scalar`: 4.0\n" + ] + } + ], "source": [ "row_vector = matrix[1]\n", "column_vector = matrix[:,1]\n", @@ -215,11 +289,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "X_YJrZsxYZ2z" - }, - "outputs": [], + "execution_count": 11, + "metadata": { + "id": "X_YJrZsxYZ2z", + "outputId": "9568e0e2-a893-4707-8b4d-0c2c84915552", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tf.Tensor(76, shape=(), dtype=int32)\n", + "tf.Tensor(76, shape=(), dtype=int32)\n" + ] + } + ], "source": [ "# Create the nodes in the graph, and initialize values\n", "a = tf.constant(15)\n", @@ -251,22 +338,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "id": "PJnfzpWyYZ23", - "scrolled": true - }, - "outputs": [], + "scrolled": true, + "outputId": "358c4158-e6c6-4a34-c9a3-3d91545658ea", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "c: tf.Tensor(76, shape=(), dtype=int32)\n", + "d: tf.Tensor(60, shape=(), dtype=int32)\n", + "e: tf.Tensor(4560, shape=(), dtype=int32)\n", + "tf.Tensor(4560, shape=(), dtype=int32)\n" + ] + } + ], "source": [ "### Defining Tensor computations ###\n", "\n", "# Construct a simple computation function\n", "def func(a,b):\n", " '''TODO: Define the operation for c, d, e (use tf.add, tf.subtract, tf.multiply).'''\n", - " c = # TODO\n", - " d = # TODO\n", - " e = # TODO\n", - " return e" + " c = tf.add(a,b)\n", + " print(\"c: \", c)\n", + " d = tf.subtract(b,1)\n", + " print(\"d: \", d)\n", + " e = tf.multiply(c,d)\n", + " print(\"e: \", e)\n", + " return e\n", + "\n", + "result = func(a,b)\n", + "print(result)" ] }, { @@ -280,11 +388,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "pnwsf8w2uF7p" - }, - "outputs": [], + "execution_count": 13, + "metadata": { + "id": "pnwsf8w2uF7p", + "outputId": "3939bf55-3d68-4942-fd58-4b1b7ea34eb5", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "c: tf.Tensor(4.0, shape=(), dtype=float32)\n", + "d: tf.Tensor(1.5, shape=(), dtype=float32)\n", + "e: tf.Tensor(6.0, shape=(), dtype=float32)\n", + "tf.Tensor(6.0, shape=(), dtype=float32)\n" + ] + } + ], "source": [ "# Consider example values for a,b\n", "a, b = 1.5, 2.5\n", @@ -320,11 +443,43 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "HutbJk-1kHPh" - }, - "outputs": [], + "execution_count": 14, + "metadata": { + "id": "HutbJk-1kHPh", + "outputId": "4dafa26c-79ed-48f7-d87c-42e9a8d5d11d", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "this is what d is: 2 \t (1, 2) \t 2\n", + "[[0.27064407 0.18269512 0.50374055]]\n", + "[PASS] test_custom_dense_layer_output\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/lib/python3.10/random.py:370: DeprecationWarning: non-integer arguments to randrange() have been deprecated since Python 3.10 and will be removed in a subsequent version\n", + " return self.randrange(a, b+1)\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 14 + } + ], "source": [ "### Defining a network Layer ###\n", "\n", @@ -339,6 +494,7 @@ "\n", " def build(self, input_shape):\n", " d = int(input_shape[-1])\n", + " print(\"this is what d is: \", d, \"\\t\", input_shape, \"\\t\", input_shape[-1])\n", " # Define and initialize parameters: a weight matrix W and bias b\n", " # Note that parameter initialization is random!\n", " self.W = self.add_weight(\"weight\", shape=[d, self.n_output_nodes]) # note the dimensionality\n", @@ -346,10 +502,10 @@ "\n", " def call(self, x):\n", " '''TODO: define the operation for z (hint: use tf.matmul)'''\n", - " z = # TODO\n", + " z = tf.matmul(x, self.W) + self.b\n", "\n", " '''TODO: define the operation for out (hint: use tf.sigmoid)'''\n", - " y = # TODO\n", + " y = tf.sigmoid(z)\n", " return y\n", "\n", "# Since layer parameters are initialized randomly, we will set a random seed for reproducibility\n", @@ -364,6 +520,15 @@ "mdl.lab1.test_custom_dense_layer_output(y)" ] }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "75l6oUYFcByr" + }, + "execution_count": null, + "outputs": [] + }, { "cell_type": "markdown", "metadata": { @@ -375,7 +540,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": { "id": "7WXTpmoL6TDz" }, @@ -397,7 +562,8 @@ "# Remember: dense layers are defined by the parameters W and b!\n", "# You can read more about the initialization of W and b in the TF documentation :)\n", "# https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense?version=stable\n", - "dense_layer = # TODO\n", + "\n", + "dense_layer = OurDenseLayer(n_output_nodes)\n", "\n", "# Add the dense layer to the model\n", "model.add(dense_layer)\n" @@ -414,17 +580,41 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "sg23OczByRDb" - }, - "outputs": [], + "execution_count": 18, + "metadata": { + "id": "sg23OczByRDb", + "outputId": "b2b6c71a-087b-4975-891e-4be35e034eb7", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "this is what d is: 2 \t (1, 2) \t 2\n", + "tf.Tensor([[0.18262717 0.08587597 0.1927509 ]], shape=(1, 3), dtype=float32)\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n", + "/usr/lib/python3.10/random.py:370: DeprecationWarning: non-integer arguments to randrange() have been deprecated since Python 3.10 and will be removed in a subsequent version\n", + " return self.randrange(a, b+1)\n" + ] + } + ], "source": [ "# Test model with example input\n", "x_input = tf.constant([[1,2.]], shape=(1,2))\n", "\n", "'''TODO: feed input into the model and predict the output!'''\n", - "model_output = # TODO\n", + "dense_layer.build((1,2))\n", + "model_output = dense_layer.call(x_input)\n", "print(model_output)" ] }, @@ -439,7 +629,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": { "id": "K4aCflPVyViD" }, @@ -456,7 +646,7 @@ " def __init__(self, n_output_nodes):\n", " super(SubclassModel, self).__init__()\n", " '''TODO: Our model consists of a single Dense layer. Define this layer.'''\n", - " self.dense_layer = '''TODO: Dense Layer'''\n", + " self.dense_layer = OurDenseLayer(n_output_nodes)\n", "\n", " # In the call function, we define the Model's forward pass.\n", " def call(self, inputs):\n", @@ -475,11 +665,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "LhB34RA-4gXb" - }, - "outputs": [], + "execution_count": 26, + "metadata": { + "id": "LhB34RA-4gXb", + "outputId": "d28b6358-4fe7-4df6-e869-e8243b03d6d9", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "this is what d is: 2 \t (1, 2) \t 2\n", + "tf.Tensor([[0.6376627 0.837621 0.96123457]], shape=(1, 3), dtype=float32)\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/lib/python3.10/random.py:370: DeprecationWarning: non-integer arguments to randrange() have been deprecated since Python 3.10 and will be removed in a subsequent version\n", + " return self.randrange(a, b+1)\n" + ] + } + ], "source": [ "n_output_nodes = 3\n", "model = SubclassModel(n_output_nodes)\n", @@ -500,11 +711,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "P7jzGX5D1xT5" - }, - "outputs": [], + "execution_count": 29, + "metadata": { + "id": "P7jzGX5D1xT5", + "outputId": "452b0f10-469a-4b72-8bb7-faff3165acba", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ], "source": [ "### Defining a model using subclassing and specifying custom behavior ###\n", "\n", @@ -523,7 +747,11 @@ " under control of the isidentity argument.'''\n", " def call(self, inputs, isidentity=False):\n", " x = self.dense_layer(inputs)\n", - " '''TODO: Implement identity behavior'''" + " '''TODO: Implement identity behavior'''\n", + " if isidentity:\n", + " return inputs\n", + " else:\n", + " return x" ] }, { @@ -537,19 +765,41 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "NzC0mgbk5dp2" - }, - "outputs": [], + "execution_count": 30, + "metadata": { + "id": "NzC0mgbk5dp2", + "outputId": "19e286e0-572c-4cd6-c13d-b920ed179868", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Network output with activation: [[0.3137059 0.09264624 0.23160182]]; network identity output: [[1. 2.]]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n", + "/usr/lib/python3.10/random.py:370: DeprecationWarning: non-integer arguments to randrange() have been deprecated since Python 3.10 and will be removed in a subsequent version\n", + " return self.randrange(a, b+1)\n" + ] + } + ], "source": [ "n_output_nodes = 3\n", "model = IdentityModel(n_output_nodes)\n", "\n", "x_input = tf.constant([[1,2.]], shape=(1,2))\n", "'''TODO: pass the input into the model and call with and without the input identity option.'''\n", - "out_activate = # TODO\n", - "out_identity = # TODO\n", + "out_activate = model.call(x_input, False)\n", + "out_identity = model.call(x_input, True)\n", "\n", "print(\"Network output with activation: {}; network identity output: {}\".format(out_activate.numpy(), out_identity.numpy()))" ] @@ -583,7 +833,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": { "id": "tdkqk8pw5yJM" }, @@ -616,7 +866,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": { "attributes": { "classes": [ @@ -624,9 +874,42 @@ ], "id": "" }, - "id": "7g1yWiSXqEf-" - }, - "outputs": [], + "id": "7g1yWiSXqEf-", + "outputId": "1dc28f3f-b558-4565-cb61-3a29d626fb4c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 504 + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Initializing x=[[-0.35975078]]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0, 0.5, 'x value')" + ] + }, + "metadata": {}, + "execution_count": 40 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], "source": [ "### Function minimization with automatic differentiation and SGD ###\n", "\n", @@ -644,7 +927,7 @@ "for i in range(500):\n", " with tf.GradientTape() as tape:\n", " '''TODO: define the loss as described above'''\n", - " loss = # TODO\n", + " loss = pow((x - x_f), 2)\n", "\n", " # loss minimization using gradient tape\n", " grad = tape.gradient(loss, x) # compute the derivative of the loss with respect to x\n", From ed77bdca8453e31a4fc507b295ce0e627c091b74 Mon Sep 17 00:00:00 2001 From: WilliamStarling <63762012+WilliamStarling@users.noreply.github.com> Date: Fri, 2 Aug 2024 18:13:02 -0500 Subject: [PATCH 5/6] Reset file to main repository This branch contained the edits I made when completing the lab, so I copied the code over from the main repository to reset it, so those edits won't be in the pull request. --- lab1/Part1_TensorFlow.ipynb | 466 +++++++----------------------------- 1 file changed, 91 insertions(+), 375 deletions(-) diff --git a/lab1/Part1_TensorFlow.ipynb b/lab1/Part1_TensorFlow.ipynb index 5c50a72a..dfa3492d 100644 --- a/lab1/Part1_TensorFlow.ipynb +++ b/lab1/Part1_TensorFlow.ipynb @@ -10,7 +10,7 @@ " \n", " \n", " Visit MIT Deep Learning\n", - " \n", + " \n", " Run in Google Colab\n", " \n", " View Source on GitHub\n", @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "id": "3eI6DUic-6jo" }, @@ -59,25 +59,11 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "LkaimNJfYZ2w", - "outputId": "d0dbc631-c28e-4e44-94c0-3e44fa4c8890", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/2.1 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.2/2.1 MB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/2.1 MB\u001b[0m \u001b[31m17.5 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.1/2.1 MB\u001b[0m \u001b[31m20.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Building wheel for mitdeeplearning (setup.py) ... \u001b[?25l\u001b[?25hdone\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "LkaimNJfYZ2w" + }, + "outputs": [], "source": [ "import tensorflow as tf\n", "\n", @@ -106,32 +92,11 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "tFxztZQInlAB", - "outputId": "748ac293-e27f-413e-e740-fc8ff8310919", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "`sport` is a 0-d Tensor\n", - "`number` is a 0-d Tensor\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "tFxztZQInlAB" + }, + "outputs": [], "source": [ "sport = tf.constant(\"Tennis\", tf.string)\n", "number = tf.constant(1.41421356237, tf.float64)\n", @@ -151,24 +116,11 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "oaHXABe8oPcO", - "outputId": "a6dd1ee0-e294-435f-beb9-14b2eb16f708", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "`sports` is a 1-d Tensor with shape: [2]\n", - "`numbers` is a 1-d Tensor with shape: [3]\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "oaHXABe8oPcO" + }, + "outputs": [], "source": [ "sports = tf.constant([\"Tennis\", \"Basketball\"], tf.string)\n", "numbers = tf.constant([3.141592, 1.414213, 2.71821], tf.float64)\n", @@ -188,37 +140,24 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "tFeBBe1IouS3", - "outputId": "e6986fe1-18aa-476f-8fa7-3e456679a9fc", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Finished running\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "tFeBBe1IouS3" + }, + "outputs": [], "source": [ "### Defining higher-order Tensors ###\n", "\n", "'''TODO: Define a 2-d Tensor'''\n", - "matrix = tf.constant([[1, 4, 3, 8], [2, 6, 12, 24]], tf.float64)\n", + "matrix = # TODO\n", "\n", "assert isinstance(matrix, tf.Tensor), \"matrix must be a tf Tensor object\"\n", - "assert tf.rank(matrix).numpy() == 2\n", - "print(\"Finished running\")" + "assert tf.rank(matrix).numpy() == 2" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { "id": "Zv1fTn_Ya_cz" }, @@ -227,7 +166,7 @@ "'''TODO: Define a 4-d Tensor.'''\n", "# Use tf.zeros to initialize a 4-d Tensor of zeros with size 10 x 256 x 256 x 3.\n", "# You can think of this as 10 images where each image is RGB 256 x 256.\n", - "images = tf.zeros([10, 256, 256, 3], tf.int32)\n", + "images = # TODO\n", "\n", "assert isinstance(images, tf.Tensor), \"matrix must be a tf Tensor object\"\n", "assert tf.rank(images).numpy() == 4, \"matrix must be of rank 4\"\n", @@ -245,25 +184,11 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "id": "FhaufyObuLEG", - "outputId": "132edaf3-3832-4b7e-c317-ff7401edfcc6", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "`row_vector`: [ 2. 6. 12. 24.]\n", - "`column_vector`: [4. 6.]\n", - "`scalar`: 4.0\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "FhaufyObuLEG" + }, + "outputs": [], "source": [ "row_vector = matrix[1]\n", "column_vector = matrix[:,1]\n", @@ -289,24 +214,11 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "id": "X_YJrZsxYZ2z", - "outputId": "9568e0e2-a893-4707-8b4d-0c2c84915552", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "tf.Tensor(76, shape=(), dtype=int32)\n", - "tf.Tensor(76, shape=(), dtype=int32)\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "X_YJrZsxYZ2z" + }, + "outputs": [], "source": [ "# Create the nodes in the graph, and initialize values\n", "a = tf.constant(15)\n", @@ -338,43 +250,22 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "id": "PJnfzpWyYZ23", - "scrolled": true, - "outputId": "358c4158-e6c6-4a34-c9a3-3d91545658ea", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "c: tf.Tensor(76, shape=(), dtype=int32)\n", - "d: tf.Tensor(60, shape=(), dtype=int32)\n", - "e: tf.Tensor(4560, shape=(), dtype=int32)\n", - "tf.Tensor(4560, shape=(), dtype=int32)\n" - ] - } - ], + "scrolled": true + }, + "outputs": [], "source": [ "### Defining Tensor computations ###\n", "\n", "# Construct a simple computation function\n", "def func(a,b):\n", " '''TODO: Define the operation for c, d, e (use tf.add, tf.subtract, tf.multiply).'''\n", - " c = tf.add(a,b)\n", - " print(\"c: \", c)\n", - " d = tf.subtract(b,1)\n", - " print(\"d: \", d)\n", - " e = tf.multiply(c,d)\n", - " print(\"e: \", e)\n", - " return e\n", - "\n", - "result = func(a,b)\n", - "print(result)" + " c = # TODO\n", + " d = # TODO\n", + " e = # TODO\n", + " return e" ] }, { @@ -388,26 +279,11 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "id": "pnwsf8w2uF7p", - "outputId": "3939bf55-3d68-4942-fd58-4b1b7ea34eb5", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "c: tf.Tensor(4.0, shape=(), dtype=float32)\n", - "d: tf.Tensor(1.5, shape=(), dtype=float32)\n", - "e: tf.Tensor(6.0, shape=(), dtype=float32)\n", - "tf.Tensor(6.0, shape=(), dtype=float32)\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "pnwsf8w2uF7p" + }, + "outputs": [], "source": [ "# Consider example values for a,b\n", "a, b = 1.5, 2.5\n", @@ -443,43 +319,11 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "id": "HutbJk-1kHPh", - "outputId": "4dafa26c-79ed-48f7-d87c-42e9a8d5d11d", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "this is what d is: 2 \t (1, 2) \t 2\n", - "[[0.27064407 0.18269512 0.50374055]]\n", - "[PASS] test_custom_dense_layer_output\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/lib/python3.10/random.py:370: DeprecationWarning: non-integer arguments to randrange() have been deprecated since Python 3.10 and will be removed in a subsequent version\n", - " return self.randrange(a, b+1)\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "True" - ] - }, - "metadata": {}, - "execution_count": 14 - } - ], + "execution_count": null, + "metadata": { + "id": "HutbJk-1kHPh" + }, + "outputs": [], "source": [ "### Defining a network Layer ###\n", "\n", @@ -494,7 +338,6 @@ "\n", " def build(self, input_shape):\n", " d = int(input_shape[-1])\n", - " print(\"this is what d is: \", d, \"\\t\", input_shape, \"\\t\", input_shape[-1])\n", " # Define and initialize parameters: a weight matrix W and bias b\n", " # Note that parameter initialization is random!\n", " self.W = self.add_weight(\"weight\", shape=[d, self.n_output_nodes]) # note the dimensionality\n", @@ -502,10 +345,10 @@ "\n", " def call(self, x):\n", " '''TODO: define the operation for z (hint: use tf.matmul)'''\n", - " z = tf.matmul(x, self.W) + self.b\n", + " z = # TODO\n", "\n", " '''TODO: define the operation for out (hint: use tf.sigmoid)'''\n", - " y = tf.sigmoid(z)\n", + " y = # TODO\n", " return y\n", "\n", "# Since layer parameters are initialized randomly, we will set a random seed for reproducibility\n", @@ -520,15 +363,6 @@ "mdl.lab1.test_custom_dense_layer_output(y)" ] }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "75l6oUYFcByr" - }, - "execution_count": null, - "outputs": [] - }, { "cell_type": "markdown", "metadata": { @@ -540,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { "id": "7WXTpmoL6TDz" }, @@ -562,8 +396,7 @@ "# Remember: dense layers are defined by the parameters W and b!\n", "# You can read more about the initialization of W and b in the TF documentation :)\n", "# https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense?version=stable\n", - "\n", - "dense_layer = OurDenseLayer(n_output_nodes)\n", + "dense_layer = # TODO\n", "\n", "# Add the dense layer to the model\n", "model.add(dense_layer)\n" @@ -580,41 +413,17 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "id": "sg23OczByRDb", - "outputId": "b2b6c71a-087b-4975-891e-4be35e034eb7", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "this is what d is: 2 \t (1, 2) \t 2\n", - "tf.Tensor([[0.18262717 0.08587597 0.1927509 ]], shape=(1, 3), dtype=float32)\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n", - "/usr/lib/python3.10/random.py:370: DeprecationWarning: non-integer arguments to randrange() have been deprecated since Python 3.10 and will be removed in a subsequent version\n", - " return self.randrange(a, b+1)\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "sg23OczByRDb" + }, + "outputs": [], "source": [ "# Test model with example input\n", "x_input = tf.constant([[1,2.]], shape=(1,2))\n", "\n", "'''TODO: feed input into the model and predict the output!'''\n", - "dense_layer.build((1,2))\n", - "model_output = dense_layer.call(x_input)\n", + "model_output = # TODO\n", "print(model_output)" ] }, @@ -629,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": { "id": "K4aCflPVyViD" }, @@ -646,7 +455,7 @@ " def __init__(self, n_output_nodes):\n", " super(SubclassModel, self).__init__()\n", " '''TODO: Our model consists of a single Dense layer. Define this layer.'''\n", - " self.dense_layer = OurDenseLayer(n_output_nodes)\n", + " self.dense_layer = '''TODO: Dense Layer'''\n", "\n", " # In the call function, we define the Model's forward pass.\n", " def call(self, inputs):\n", @@ -665,32 +474,11 @@ }, { "cell_type": "code", - "execution_count": 26, - "metadata": { - "id": "LhB34RA-4gXb", - "outputId": "d28b6358-4fe7-4df6-e869-e8243b03d6d9", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "this is what d is: 2 \t (1, 2) \t 2\n", - "tf.Tensor([[0.6376627 0.837621 0.96123457]], shape=(1, 3), dtype=float32)\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/lib/python3.10/random.py:370: DeprecationWarning: non-integer arguments to randrange() have been deprecated since Python 3.10 and will be removed in a subsequent version\n", - " return self.randrange(a, b+1)\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "LhB34RA-4gXb" + }, + "outputs": [], "source": [ "n_output_nodes = 3\n", "model = SubclassModel(n_output_nodes)\n", @@ -711,24 +499,11 @@ }, { "cell_type": "code", - "execution_count": 29, - "metadata": { - "id": "P7jzGX5D1xT5", - "outputId": "452b0f10-469a-4b72-8bb7-faff3165acba", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "P7jzGX5D1xT5" + }, + "outputs": [], "source": [ "### Defining a model using subclassing and specifying custom behavior ###\n", "\n", @@ -747,11 +522,7 @@ " under control of the isidentity argument.'''\n", " def call(self, inputs, isidentity=False):\n", " x = self.dense_layer(inputs)\n", - " '''TODO: Implement identity behavior'''\n", - " if isidentity:\n", - " return inputs\n", - " else:\n", - " return x" + " '''TODO: Implement identity behavior'''" ] }, { @@ -765,41 +536,19 @@ }, { "cell_type": "code", - "execution_count": 30, - "metadata": { - "id": "NzC0mgbk5dp2", - "outputId": "19e286e0-572c-4cd6-c13d-b920ed179868", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Network output with activation: [[0.3137059 0.09264624 0.23160182]]; network identity output: [[1. 2.]]\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n", - "/usr/lib/python3.10/random.py:370: DeprecationWarning: non-integer arguments to randrange() have been deprecated since Python 3.10 and will be removed in a subsequent version\n", - " return self.randrange(a, b+1)\n" - ] - } - ], + "execution_count": null, + "metadata": { + "id": "NzC0mgbk5dp2" + }, + "outputs": [], "source": [ "n_output_nodes = 3\n", "model = IdentityModel(n_output_nodes)\n", "\n", "x_input = tf.constant([[1,2.]], shape=(1,2))\n", "'''TODO: pass the input into the model and call with and without the input identity option.'''\n", - "out_activate = model.call(x_input, False)\n", - "out_identity = model.call(x_input, True)\n", + "out_activate = # TODO\n", + "out_identity = # TODO\n", "\n", "print(\"Network output with activation: {}; network identity output: {}\".format(out_activate.numpy(), out_identity.numpy()))" ] @@ -833,7 +582,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": { "id": "tdkqk8pw5yJM" }, @@ -866,7 +615,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": { "attributes": { "classes": [ @@ -874,42 +623,9 @@ ], "id": "" }, - "id": "7g1yWiSXqEf-", - "outputId": "1dc28f3f-b558-4565-cb61-3a29d626fb4c", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 504 - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Initializing x=[[-0.35975078]]\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Text(0, 0.5, 'x value')" - ] - }, - "metadata": {}, - "execution_count": 40 - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], + "id": "7g1yWiSXqEf-" + }, + "outputs": [], "source": [ "### Function minimization with automatic differentiation and SGD ###\n", "\n", @@ -927,7 +643,7 @@ "for i in range(500):\n", " with tf.GradientTape() as tape:\n", " '''TODO: define the loss as described above'''\n", - " loss = pow((x - x_f), 2)\n", + " loss = # TODO\n", "\n", " # loss minimization using gradient tape\n", " grad = tape.gradient(loss, x) # compute the derivative of the loss with respect to x\n", @@ -979,4 +695,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} From 20d8f1456dbe6a1c78fb28df182fec805a02bfbb Mon Sep 17 00:00:00 2001 From: WilliamStarling <63762012+WilliamStarling@users.noreply.github.com> Date: Fri, 2 Aug 2024 18:16:15 -0500 Subject: [PATCH 6/6] Fixed bug "TypeError: Layer.add_weight() got multiple values for argument 'shape'" Google Colab thought "weight" and "bias" were being given for the "shape" argument, so I specified that these are the names of the variable and that fixed it. --- lab1/Part1_TensorFlow.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lab1/Part1_TensorFlow.ipynb b/lab1/Part1_TensorFlow.ipynb index dfa3492d..01323f88 100644 --- a/lab1/Part1_TensorFlow.ipynb +++ b/lab1/Part1_TensorFlow.ipynb @@ -340,8 +340,8 @@ " d = int(input_shape[-1])\n", " # Define and initialize parameters: a weight matrix W and bias b\n", " # Note that parameter initialization is random!\n", - " self.W = self.add_weight(\"weight\", shape=[d, self.n_output_nodes]) # note the dimensionality\n", - " self.b = self.add_weight(\"bias\", shape=[1, self.n_output_nodes]) # note the dimensionality\n", + " self.W = self.add_weight(name=\"weight\", shape=[d, self.n_output_nodes]) # note the dimensionality\n", + " self.b = self.add_weight(name=\"bias\", shape=[1, self.n_output_nodes]) # note the dimensionality\n", "\n", " def call(self, x):\n", " '''TODO: define the operation for z (hint: use tf.matmul)'''\n",