chore(i18n): sync translations with latest source changes (chunk 3/4, 218 changes)

translations/pa/.co-op-translator.json

@@ -0,0 +1,596 @@
+{
+  "1-Introduction/1-intro-to-ML/README.md": {
+    "original_hash": "69389392fa6346e0dfa30f664b7b6fec",
+    "translation_date": "2025-09-06T07:05:22+00:00",
+    "source_file": "1-Introduction/1-intro-to-ML/README.md",
+    "language_code": "pa"
+  },
+  "1-Introduction/1-intro-to-ML/assignment.md": {
+    "original_hash": "4c4698044bb8af52cfb6388a4ee0e53b",
+    "translation_date": "2025-08-29T17:41:44+00:00",
+    "source_file": "1-Introduction/1-intro-to-ML/assignment.md",
+    "language_code": "pa"
+  },
+  "1-Introduction/2-history-of-ML/README.md": {
+    "original_hash": "6a05fec147e734c3e6bfa54505648e2b",
+    "translation_date": "2025-09-06T07:06:44+00:00",
+    "source_file": "1-Introduction/2-history-of-ML/README.md",
+    "language_code": "pa"
+  },
+  "1-Introduction/2-history-of-ML/assignment.md": {
+    "original_hash": "eb6e4d5afd1b21a57d2b9e6d0aac3969",
+    "translation_date": "2025-08-29T17:44:18+00:00",
+    "source_file": "1-Introduction/2-history-of-ML/assignment.md",
+    "language_code": "pa"
+  },
+  "1-Introduction/3-fairness/README.md": {
+    "original_hash": "9a6b702d1437c0467e3c5c28d763dac2",
+    "translation_date": "2025-09-06T07:03:15+00:00",
+    "source_file": "1-Introduction/3-fairness/README.md",
+    "language_code": "pa"
+  },
+  "1-Introduction/3-fairness/assignment.md": {
+    "original_hash": "dbda60e7b1fe5f18974e7858eff0004e",
+    "translation_date": "2025-08-29T17:34:47+00:00",
+    "source_file": "1-Introduction/3-fairness/assignment.md",
+    "language_code": "pa"
+  },
+  "1-Introduction/4-techniques-of-ML/README.md": {
+    "original_hash": "9d91f3af3758fdd4569fb410575995ef",
+    "translation_date": "2025-09-06T07:04:42+00:00",
+    "source_file": "1-Introduction/4-techniques-of-ML/README.md",
+    "language_code": "pa"
+  },
+  "1-Introduction/4-techniques-of-ML/assignment.md": {
+    "original_hash": "70d65aeddc06170bc1aed5b27805f930",
+    "translation_date": "2025-08-29T17:39:13+00:00",
+    "source_file": "1-Introduction/4-techniques-of-ML/assignment.md",
+    "language_code": "pa"
+  },
+  "1-Introduction/README.md": {
+    "original_hash": "cf8ecc83f28e5b98051d2179eca08e08",
+    "translation_date": "2025-08-29T17:30:20+00:00",
+    "source_file": "1-Introduction/README.md",
+    "language_code": "pa"
+  },
+  "2-Regression/1-Tools/README.md": {
+    "original_hash": "fa81d226c71d5af7a2cade31c1c92b88",
+    "translation_date": "2025-09-06T06:50:17+00:00",
+    "source_file": "2-Regression/1-Tools/README.md",
+    "language_code": "pa"
+  },
+  "2-Regression/1-Tools/assignment.md": {
+    "original_hash": "74a5cf83e4ebc302afbcbc4f418afd0a",
+    "translation_date": "2025-08-29T16:51:51+00:00",
+    "source_file": "2-Regression/1-Tools/assignment.md",
+    "language_code": "pa"
+  },
+  "2-Regression/1-Tools/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T16:52:07+00:00",
+    "source_file": "2-Regression/1-Tools/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "2-Regression/2-Data/README.md": {
+    "original_hash": "7c077988328ebfe33b24d07945f16eca",
+    "translation_date": "2025-09-06T06:51:45+00:00",
+    "source_file": "2-Regression/2-Data/README.md",
+    "language_code": "pa"
+  },
+  "2-Regression/2-Data/assignment.md": {
+    "original_hash": "4485a1ed4dd1b5647365e3d87456515d",
+    "translation_date": "2025-08-29T16:56:04+00:00",
+    "source_file": "2-Regression/2-Data/assignment.md",
+    "language_code": "pa"
+  },
+  "2-Regression/2-Data/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T16:56:18+00:00",
+    "source_file": "2-Regression/2-Data/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "2-Regression/3-Linear/README.md": {
+    "original_hash": "40e64f004f3cb50aa1d8661672d3cd92",
+    "translation_date": "2025-09-06T06:46:31+00:00",
+    "source_file": "2-Regression/3-Linear/README.md",
+    "language_code": "pa"
+  },
+  "2-Regression/3-Linear/assignment.md": {
+    "original_hash": "cc471fa89c293bc735dd3a9a0fb79b1b",
+    "translation_date": "2025-08-29T16:41:58+00:00",
+    "source_file": "2-Regression/3-Linear/assignment.md",
+    "language_code": "pa"
+  },
+  "2-Regression/3-Linear/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T16:42:14+00:00",
+    "source_file": "2-Regression/3-Linear/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "2-Regression/4-Logistic/README.md": {
+    "original_hash": "abf86d845c84330bce205a46b382ec88",
+    "translation_date": "2025-09-06T06:48:36+00:00",
+    "source_file": "2-Regression/4-Logistic/README.md",
+    "language_code": "pa"
+  },
+  "2-Regression/4-Logistic/assignment.md": {
+    "original_hash": "8af40209a41494068c1f42b14c0b450d",
+    "translation_date": "2025-08-29T16:47:24+00:00",
+    "source_file": "2-Regression/4-Logistic/assignment.md",
+    "language_code": "pa"
+  },
+  "2-Regression/4-Logistic/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T16:47:41+00:00",
+    "source_file": "2-Regression/4-Logistic/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "2-Regression/README.md": {
+    "original_hash": "508582278dbb8edd2a8a80ac96ef416c",
+    "translation_date": "2025-08-29T16:35:23+00:00",
+    "source_file": "2-Regression/README.md",
+    "language_code": "pa"
+  },
+  "3-Web-App/1-Web-App/README.md": {
+    "original_hash": "e0b75f73e4a90d45181dc5581fe2ef5c",
+    "translation_date": "2025-09-06T07:07:24+00:00",
+    "source_file": "3-Web-App/1-Web-App/README.md",
+    "language_code": "pa"
+  },
+  "3-Web-App/1-Web-App/assignment.md": {
+    "original_hash": "a8e8ae10be335cbc745b75ee552317ff",
+    "translation_date": "2025-08-29T17:47:37+00:00",
+    "source_file": "3-Web-App/1-Web-App/assignment.md",
+    "language_code": "pa"
+  },
+  "3-Web-App/README.md": {
+    "original_hash": "9836ff53cfef716ddfd70e06c5f43436",
+    "translation_date": "2025-08-29T17:44:46+00:00",
+    "source_file": "3-Web-App/README.md",
+    "language_code": "pa"
+  },
+  "4-Classification/1-Introduction/README.md": {
+    "original_hash": "aaf391d922bd6de5efba871d514c6d47",
+    "translation_date": "2025-09-06T07:10:09+00:00",
+    "source_file": "4-Classification/1-Introduction/README.md",
+    "language_code": "pa"
+  },
+  "4-Classification/1-Introduction/assignment.md": {
+    "original_hash": "b2a01912beb24cfb0007f83594dba801",
+    "translation_date": "2025-08-29T17:59:18+00:00",
+    "source_file": "4-Classification/1-Introduction/assignment.md",
+    "language_code": "pa"
+  },
+  "4-Classification/1-Introduction/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T17:59:34+00:00",
+    "source_file": "4-Classification/1-Introduction/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "4-Classification/2-Classifiers-1/README.md": {
+    "original_hash": "1a6e9e46b34a2e559fbbfc1f95397c7b",
+    "translation_date": "2025-09-06T07:08:07+00:00",
+    "source_file": "4-Classification/2-Classifiers-1/README.md",
+    "language_code": "pa"
+  },
+  "4-Classification/2-Classifiers-1/assignment.md": {
+    "original_hash": "de6025f96841498b0577e9d1aee18d1f",
+    "translation_date": "2025-08-29T17:52:10+00:00",
+    "source_file": "4-Classification/2-Classifiers-1/assignment.md",
+    "language_code": "pa"
+  },
+  "4-Classification/2-Classifiers-1/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T17:52:26+00:00",
+    "source_file": "4-Classification/2-Classifiers-1/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "4-Classification/3-Classifiers-2/README.md": {
+    "original_hash": "49047911108adc49d605cddfb455749c",
+    "translation_date": "2025-09-06T07:09:41+00:00",
+    "source_file": "4-Classification/3-Classifiers-2/README.md",
+    "language_code": "pa"
+  },
+  "4-Classification/3-Classifiers-2/assignment.md": {
+    "original_hash": "58dfdaf79fb73f7d34b22bdbacf57329",
+    "translation_date": "2025-08-29T17:56:40+00:00",
+    "source_file": "4-Classification/3-Classifiers-2/assignment.md",
+    "language_code": "pa"
+  },
+  "4-Classification/3-Classifiers-2/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T17:56:58+00:00",
+    "source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "4-Classification/4-Applied/README.md": {
+    "original_hash": "61bdec27ed2da8b098cd9065405d9bb0",
+    "translation_date": "2025-09-06T07:09:21+00:00",
+    "source_file": "4-Classification/4-Applied/README.md",
+    "language_code": "pa"
+  },
+  "4-Classification/4-Applied/assignment.md": {
+    "original_hash": "799ed651e2af0a7cad17c6268db11578",
+    "translation_date": "2025-08-29T17:54:43+00:00",
+    "source_file": "4-Classification/4-Applied/assignment.md",
+    "language_code": "pa"
+  },
+  "4-Classification/README.md": {
+    "original_hash": "74e809ffd1e613a1058bbc3e9600859e",
+    "translation_date": "2025-08-29T17:48:57+00:00",
+    "source_file": "4-Classification/README.md",
+    "language_code": "pa"
+  },
+  "5-Clustering/1-Visualize/README.md": {
+    "original_hash": "730225ea274c9174fe688b21d421539d",
+    "translation_date": "2025-09-06T06:57:24+00:00",
+    "source_file": "5-Clustering/1-Visualize/README.md",
+    "language_code": "pa"
+  },
+  "5-Clustering/1-Visualize/assignment.md": {
+    "original_hash": "589fa015a5e7d9e67bd629f7d47b53de",
+    "translation_date": "2025-08-29T17:16:30+00:00",
+    "source_file": "5-Clustering/1-Visualize/assignment.md",
+    "language_code": "pa"
+  },
+  "5-Clustering/1-Visualize/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T17:16:50+00:00",
+    "source_file": "5-Clustering/1-Visualize/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "5-Clustering/2-K-Means/README.md": {
+    "original_hash": "7cdd17338d9bbd7e2171c2cd462eb081",
+    "translation_date": "2025-09-06T06:58:34+00:00",
+    "source_file": "5-Clustering/2-K-Means/README.md",
+    "language_code": "pa"
+  },
+  "5-Clustering/2-K-Means/assignment.md": {
+    "original_hash": "b8e17eff34ad1680eba2a5d3cf9ffc41",
+    "translation_date": "2025-08-29T17:18:56+00:00",
+    "source_file": "5-Clustering/2-K-Means/assignment.md",
+    "language_code": "pa"
+  },
+  "5-Clustering/2-K-Means/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T17:19:12+00:00",
+    "source_file": "5-Clustering/2-K-Means/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "5-Clustering/README.md": {
+    "original_hash": "b28a3a4911584062772c537b653ebbc7",
+    "translation_date": "2025-08-29T17:08:26+00:00",
+    "source_file": "5-Clustering/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/1-Introduction-to-NLP/README.md": {
+    "original_hash": "1c2ec40cf55c98a028a359c27ef7e45a",
+    "translation_date": "2025-09-06T07:19:50+00:00",
+    "source_file": "6-NLP/1-Introduction-to-NLP/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/1-Introduction-to-NLP/assignment.md": {
+    "original_hash": "1d7583e8046dacbb0c056d5ba0a71b16",
+    "translation_date": "2025-08-29T18:32:49+00:00",
+    "source_file": "6-NLP/1-Introduction-to-NLP/assignment.md",
+    "language_code": "pa"
+  },
+  "6-NLP/2-Tasks/README.md": {
+    "original_hash": "5f3cb462e3122e1afe7ab0050ccf2bd3",
+    "translation_date": "2025-09-06T07:15:46+00:00",
+    "source_file": "6-NLP/2-Tasks/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/2-Tasks/assignment.md": {
+    "original_hash": "2efc4c2aba5ed06c780c05539c492ae3",
+    "translation_date": "2025-08-29T18:22:33+00:00",
+    "source_file": "6-NLP/2-Tasks/assignment.md",
+    "language_code": "pa"
+  },
+  "6-NLP/3-Translation-Sentiment/README.md": {
+    "original_hash": "be03c8182982b87ced155e4e9d1438e8",
+    "translation_date": "2025-09-06T07:21:25+00:00",
+    "source_file": "6-NLP/3-Translation-Sentiment/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/3-Translation-Sentiment/assignment.md": {
+    "original_hash": "9d2a734deb904caff310d1a999c6bd7a",
+    "translation_date": "2025-08-29T18:37:00+00:00",
+    "source_file": "6-NLP/3-Translation-Sentiment/assignment.md",
+    "language_code": "pa"
+  },
+  "6-NLP/3-Translation-Sentiment/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T18:37:30+00:00",
+    "source_file": "6-NLP/3-Translation-Sentiment/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/3-Translation-Sentiment/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T18:37:16+00:00",
+    "source_file": "6-NLP/3-Translation-Sentiment/solution/R/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/4-Hotel-Reviews-1/README.md": {
+    "original_hash": "8d32dadeda93c6fb5c43619854882ab1",
+    "translation_date": "2025-09-06T07:17:55+00:00",
+    "source_file": "6-NLP/4-Hotel-Reviews-1/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/4-Hotel-Reviews-1/assignment.md": {
+    "original_hash": "bf39bceb833cd628f224941dca8041df",
+    "translation_date": "2025-08-29T18:28:51+00:00",
+    "source_file": "6-NLP/4-Hotel-Reviews-1/assignment.md",
+    "language_code": "pa"
+  },
+  "6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T18:29:20+00:00",
+    "source_file": "6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/4-Hotel-Reviews-1/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T18:29:07+00:00",
+    "source_file": "6-NLP/4-Hotel-Reviews-1/solution/R/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/5-Hotel-Reviews-2/README.md": {
+    "original_hash": "2c742993fe95d5bcbb2846eda3d442a1",
+    "translation_date": "2025-09-06T07:22:48+00:00",
+    "source_file": "6-NLP/5-Hotel-Reviews-2/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/5-Hotel-Reviews-2/assignment.md": {
+    "original_hash": "daf144daa552da6a7d442aff6f3e77d8",
+    "translation_date": "2025-08-29T18:42:57+00:00",
+    "source_file": "6-NLP/5-Hotel-Reviews-2/assignment.md",
+    "language_code": "pa"
+  },
+  "6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T18:43:23+00:00",
+    "source_file": "6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/5-Hotel-Reviews-2/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T18:43:12+00:00",
+    "source_file": "6-NLP/5-Hotel-Reviews-2/solution/R/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/README.md": {
+    "original_hash": "1eb379dc2d0c9940b320732d16083778",
+    "translation_date": "2025-08-29T18:18:55+00:00",
+    "source_file": "6-NLP/README.md",
+    "language_code": "pa"
+  },
+  "6-NLP/data/README.md": {
+    "original_hash": "ee0670655c89e4719319764afb113624",
+    "translation_date": "2025-08-29T18:29:31+00:00",
+    "source_file": "6-NLP/data/README.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/1-Introduction/README.md": {
+    "original_hash": "662b509c39eee205687726636d0a8455",
+    "translation_date": "2025-09-06T06:54:47+00:00",
+    "source_file": "7-TimeSeries/1-Introduction/README.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/1-Introduction/assignment.md": {
+    "original_hash": "d1781b0b92568ea1d119d0a198b576b4",
+    "translation_date": "2025-08-29T17:05:04+00:00",
+    "source_file": "7-TimeSeries/1-Introduction/assignment.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/1-Introduction/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T17:05:31+00:00",
+    "source_file": "7-TimeSeries/1-Introduction/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/1-Introduction/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T17:05:20+00:00",
+    "source_file": "7-TimeSeries/1-Introduction/solution/R/README.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/2-ARIMA/README.md": {
+    "original_hash": "917dbf890db71a322f306050cb284749",
+    "translation_date": "2025-09-06T06:53:15+00:00",
+    "source_file": "7-TimeSeries/2-ARIMA/README.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/2-ARIMA/assignment.md": {
+    "original_hash": "1c814013e10866dfd92cdb32caaae3ac",
+    "translation_date": "2025-08-29T17:01:23+00:00",
+    "source_file": "7-TimeSeries/2-ARIMA/assignment.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/2-ARIMA/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T17:01:51+00:00",
+    "source_file": "7-TimeSeries/2-ARIMA/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/2-ARIMA/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T17:01:39+00:00",
+    "source_file": "7-TimeSeries/2-ARIMA/solution/R/README.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/3-SVR/README.md": {
+    "original_hash": "482bccabe1df958496ea71a3667995cd",
+    "translation_date": "2025-09-06T06:55:27+00:00",
+    "source_file": "7-TimeSeries/3-SVR/README.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/3-SVR/assignment.md": {
+    "original_hash": "94aa2fc6154252ae30a3f3740299707a",
+    "translation_date": "2025-08-29T17:07:53+00:00",
+    "source_file": "7-TimeSeries/3-SVR/assignment.md",
+    "language_code": "pa"
+  },
+  "7-TimeSeries/README.md": {
+    "original_hash": "61342603bad8acadbc6b2e4e3aab3f66",
+    "translation_date": "2025-08-29T16:56:46+00:00",
+    "source_file": "7-TimeSeries/README.md",
+    "language_code": "pa"
+  },
+  "8-Reinforcement/1-QLearning/README.md": {
+    "original_hash": "911efd5e595089000cb3c16fce1beab8",
+    "translation_date": "2025-09-06T07:11:50+00:00",
+    "source_file": "8-Reinforcement/1-QLearning/README.md",
+    "language_code": "pa"
+  },
+  "8-Reinforcement/1-QLearning/assignment.md": {
+    "original_hash": "68394b2102d3503882e5e914bd0ff5c1",
+    "translation_date": "2025-08-29T18:13:49+00:00",
+    "source_file": "8-Reinforcement/1-QLearning/assignment.md",
+    "language_code": "pa"
+  },
+  "8-Reinforcement/1-QLearning/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T18:14:21+00:00",
+    "source_file": "8-Reinforcement/1-QLearning/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "8-Reinforcement/1-QLearning/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T18:14:11+00:00",
+    "source_file": "8-Reinforcement/1-QLearning/solution/R/README.md",
+    "language_code": "pa"
+  },
+  "8-Reinforcement/2-Gym/README.md": {
+    "original_hash": "107d5bb29da8a562e7ae72262d251a75",
+    "translation_date": "2025-09-06T07:14:05+00:00",
+    "source_file": "8-Reinforcement/2-Gym/README.md",
+    "language_code": "pa"
+  },
+  "8-Reinforcement/2-Gym/assignment.md": {
+    "original_hash": "1f2b7441745eb52e25745423b247016b",
+    "translation_date": "2025-08-29T18:17:46+00:00",
+    "source_file": "8-Reinforcement/2-Gym/assignment.md",
+    "language_code": "pa"
+  },
+  "8-Reinforcement/2-Gym/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T18:18:23+00:00",
+    "source_file": "8-Reinforcement/2-Gym/solution/Julia/README.md",
+    "language_code": "pa"
+  },
+  "8-Reinforcement/2-Gym/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T18:18:11+00:00",
+    "source_file": "8-Reinforcement/2-Gym/solution/R/README.md",
+    "language_code": "pa"
+  },
+  "8-Reinforcement/README.md": {
+    "original_hash": "20ca019012b1725de956681d036d8b18",
+    "translation_date": "2025-08-29T18:05:32+00:00",
+    "source_file": "8-Reinforcement/README.md",
+    "language_code": "pa"
+  },
+  "9-Real-World/1-Applications/README.md": {
+    "original_hash": "83320d6b6994909e35d830cebf214039",
+    "translation_date": "2025-09-06T06:59:52+00:00",
+    "source_file": "9-Real-World/1-Applications/README.md",
+    "language_code": "pa"
+  },
+  "9-Real-World/1-Applications/assignment.md": {
+    "original_hash": "fdebfcd0a3f12c9e2b436ded1aa79885",
+    "translation_date": "2025-08-29T17:24:22+00:00",
+    "source_file": "9-Real-World/1-Applications/assignment.md",
+    "language_code": "pa"
+  },
+  "9-Real-World/2-Debugging-ML-Models/README.md": {
+    "original_hash": "df2b538e8fbb3e91cf0419ae2f858675",
+    "translation_date": "2025-09-06T07:01:30+00:00",
+    "source_file": "9-Real-World/2-Debugging-ML-Models/README.md",
+    "language_code": "pa"
+  },
+  "9-Real-World/2-Debugging-ML-Models/assignment.md": {
+    "original_hash": "91c6a180ef08e20cc15acfd2d6d6e164",
+    "translation_date": "2025-08-29T17:29:51+00:00",
+    "source_file": "9-Real-World/2-Debugging-ML-Models/assignment.md",
+    "language_code": "pa"
+  },
+  "9-Real-World/README.md": {
+    "original_hash": "5e069a0ac02a9606a69946c2b3c574a9",
+    "translation_date": "2025-08-29T17:20:15+00:00",
+    "source_file": "9-Real-World/README.md",
+    "language_code": "pa"
+  },
+  "AGENTS.md": {
+    "original_hash": "93fdaa0fd38836e50c4793e2f2f25e8b",
+    "translation_date": "2025-10-03T11:05:19+00:00",
+    "source_file": "AGENTS.md",
+    "language_code": "pa"
+  },
+  "CODE_OF_CONDUCT.md": {
+    "original_hash": "c06b12caf3c901eb3156e3dd5b0aea56",
+    "translation_date": "2025-08-29T16:34:38+00:00",
+    "source_file": "CODE_OF_CONDUCT.md",
+    "language_code": "pa"
+  },
+  "CONTRIBUTING.md": {
+    "original_hash": "977ec5266dfd78ad1ce2bd8d46fccbda",
+    "translation_date": "2025-08-29T16:32:33+00:00",
+    "source_file": "CONTRIBUTING.md",
+    "language_code": "pa"
+  },
+  "README.md": {
+    "original_hash": "da2ceed62f16a0820259556e3a873c95",
+    "translation_date": "2026-01-29T18:16:50+00:00",
+    "source_file": "README.md",
+    "language_code": "pa"
+  },
+  "SECURITY.md": {
+    "original_hash": "5e1b8da31aae9cca3d53ad243fa3365a",
+    "translation_date": "2025-08-29T16:33:19+00:00",
+    "source_file": "SECURITY.md",
+    "language_code": "pa"
+  },
+  "SUPPORT.md": {
+    "original_hash": "09623d7343ff1c26ff4f198c1b2d3176",
+    "translation_date": "2025-10-03T11:55:23+00:00",
+    "source_file": "SUPPORT.md",
+    "language_code": "pa"
+  },
+  "TROUBLESHOOTING.md": {
+    "original_hash": "134d8759f0e2ab886e9aa4f62362c201",
+    "translation_date": "2025-10-03T12:43:02+00:00",
+    "source_file": "TROUBLESHOOTING.md",
+    "language_code": "pa"
+  },
+  "docs/_sidebar.md": {
+    "original_hash": "68dd06c685f6ce840e0acfa313352e7c",
+    "translation_date": "2025-08-29T17:19:42+00:00",
+    "source_file": "docs/_sidebar.md",
+    "language_code": "pa"
+  },
+  "for-teachers.md": {
+    "original_hash": "b37de02054fa6c0438ede6fabe1fdfb8",
+    "translation_date": "2025-08-29T16:34:03+00:00",
+    "source_file": "for-teachers.md",
+    "language_code": "pa"
+  },
+  "quiz-app/README.md": {
+    "original_hash": "6d130dffca5db70d7e615f926cb1ad4c",
+    "translation_date": "2025-08-29T17:48:16+00:00",
+    "source_file": "quiz-app/README.md",
+    "language_code": "pa"
+  },
+  "sketchnotes/LICENSE.md": {
+    "original_hash": "fba3b94d88bfb9b81369b869a1e9a20f",
+    "translation_date": "2025-08-29T18:03:59+00:00",
+    "source_file": "sketchnotes/LICENSE.md",
+    "language_code": "pa"
+  },
+  "sketchnotes/README.md": {
+    "original_hash": "a88d5918c1b9da69a40d917a0840c497",
+    "translation_date": "2025-08-29T17:59:52+00:00",
+    "source_file": "sketchnotes/README.md",
+    "language_code": "pa"
+  }
+}

translations/pt-BR/.co-op-translator.json

@@ -0,0 +1,596 @@
+{
+  "1-Introduction/1-intro-to-ML/README.md": {
+    "original_hash": "69389392fa6346e0dfa30f664b7b6fec",
+    "translation_date": "2025-09-04T21:36:24+00:00",
+    "source_file": "1-Introduction/1-intro-to-ML/README.md",
+    "language_code": "pt-BR"
+  },
+  "1-Introduction/1-intro-to-ML/assignment.md": {
+    "original_hash": "4c4698044bb8af52cfb6388a4ee0e53b",
+    "translation_date": "2025-08-29T21:30:36+00:00",
+    "source_file": "1-Introduction/1-intro-to-ML/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "1-Introduction/2-history-of-ML/README.md": {
+    "original_hash": "6a05fec147e734c3e6bfa54505648e2b",
+    "translation_date": "2025-09-04T21:37:10+00:00",
+    "source_file": "1-Introduction/2-history-of-ML/README.md",
+    "language_code": "pt-BR"
+  },
+  "1-Introduction/2-history-of-ML/assignment.md": {
+    "original_hash": "eb6e4d5afd1b21a57d2b9e6d0aac3969",
+    "translation_date": "2025-08-29T21:34:04+00:00",
+    "source_file": "1-Introduction/2-history-of-ML/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "1-Introduction/3-fairness/README.md": {
+    "original_hash": "9a6b702d1437c0467e3c5c28d763dac2",
+    "translation_date": "2025-09-04T21:34:04+00:00",
+    "source_file": "1-Introduction/3-fairness/README.md",
+    "language_code": "pt-BR"
+  },
+  "1-Introduction/3-fairness/assignment.md": {
+    "original_hash": "dbda60e7b1fe5f18974e7858eff0004e",
+    "translation_date": "2025-08-29T21:24:15+00:00",
+    "source_file": "1-Introduction/3-fairness/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "1-Introduction/4-techniques-of-ML/README.md": {
+    "original_hash": "9d91f3af3758fdd4569fb410575995ef",
+    "translation_date": "2025-09-04T21:35:13+00:00",
+    "source_file": "1-Introduction/4-techniques-of-ML/README.md",
+    "language_code": "pt-BR"
+  },
+  "1-Introduction/4-techniques-of-ML/assignment.md": {
+    "original_hash": "70d65aeddc06170bc1aed5b27805f930",
+    "translation_date": "2025-08-29T21:27:34+00:00",
+    "source_file": "1-Introduction/4-techniques-of-ML/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "1-Introduction/README.md": {
+    "original_hash": "cf8ecc83f28e5b98051d2179eca08e08",
+    "translation_date": "2025-08-29T21:19:33+00:00",
+    "source_file": "1-Introduction/README.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/1-Tools/README.md": {
+    "original_hash": "fa81d226c71d5af7a2cade31c1c92b88",
+    "translation_date": "2025-09-04T21:24:44+00:00",
+    "source_file": "2-Regression/1-Tools/README.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/1-Tools/assignment.md": {
+    "original_hash": "74a5cf83e4ebc302afbcbc4f418afd0a",
+    "translation_date": "2025-08-29T20:33:30+00:00",
+    "source_file": "2-Regression/1-Tools/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/1-Tools/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T20:33:54+00:00",
+    "source_file": "2-Regression/1-Tools/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/2-Data/README.md": {
+    "original_hash": "7c077988328ebfe33b24d07945f16eca",
+    "translation_date": "2025-09-04T21:25:44+00:00",
+    "source_file": "2-Regression/2-Data/README.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/2-Data/assignment.md": {
+    "original_hash": "4485a1ed4dd1b5647365e3d87456515d",
+    "translation_date": "2025-08-29T20:37:30+00:00",
+    "source_file": "2-Regression/2-Data/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/2-Data/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T20:38:00+00:00",
+    "source_file": "2-Regression/2-Data/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/3-Linear/README.md": {
+    "original_hash": "40e64f004f3cb50aa1d8661672d3cd92",
+    "translation_date": "2025-09-04T21:20:40+00:00",
+    "source_file": "2-Regression/3-Linear/README.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/3-Linear/assignment.md": {
+    "original_hash": "cc471fa89c293bc735dd3a9a0fb79b1b",
+    "translation_date": "2025-08-29T20:19:42+00:00",
+    "source_file": "2-Regression/3-Linear/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/3-Linear/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T20:20:05+00:00",
+    "source_file": "2-Regression/3-Linear/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/4-Logistic/README.md": {
+    "original_hash": "abf86d845c84330bce205a46b382ec88",
+    "translation_date": "2025-09-04T21:23:34+00:00",
+    "source_file": "2-Regression/4-Logistic/README.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/4-Logistic/assignment.md": {
+    "original_hash": "8af40209a41494068c1f42b14c0b450d",
+    "translation_date": "2025-08-29T20:28:50+00:00",
+    "source_file": "2-Regression/4-Logistic/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/4-Logistic/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T20:29:15+00:00",
+    "source_file": "2-Regression/4-Logistic/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "2-Regression/README.md": {
+    "original_hash": "508582278dbb8edd2a8a80ac96ef416c",
+    "translation_date": "2025-08-29T20:13:26+00:00",
+    "source_file": "2-Regression/README.md",
+    "language_code": "pt-BR"
+  },
+  "3-Web-App/1-Web-App/README.md": {
+    "original_hash": "e0b75f73e4a90d45181dc5581fe2ef5c",
+    "translation_date": "2025-09-04T21:38:11+00:00",
+    "source_file": "3-Web-App/1-Web-App/README.md",
+    "language_code": "pt-BR"
+  },
+  "3-Web-App/1-Web-App/assignment.md": {
+    "original_hash": "a8e8ae10be335cbc745b75ee552317ff",
+    "translation_date": "2025-08-29T21:38:10+00:00",
+    "source_file": "3-Web-App/1-Web-App/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "3-Web-App/README.md": {
+    "original_hash": "9836ff53cfef716ddfd70e06c5f43436",
+    "translation_date": "2025-08-29T21:34:41+00:00",
+    "source_file": "3-Web-App/README.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/1-Introduction/README.md": {
+    "original_hash": "aaf391d922bd6de5efba871d514c6d47",
+    "translation_date": "2025-09-04T21:41:01+00:00",
+    "source_file": "4-Classification/1-Introduction/README.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/1-Introduction/assignment.md": {
+    "original_hash": "b2a01912beb24cfb0007f83594dba801",
+    "translation_date": "2025-08-29T21:54:04+00:00",
+    "source_file": "4-Classification/1-Introduction/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/1-Introduction/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T21:54:29+00:00",
+    "source_file": "4-Classification/1-Introduction/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/2-Classifiers-1/README.md": {
+    "original_hash": "1a6e9e46b34a2e559fbbfc1f95397c7b",
+    "translation_date": "2025-09-04T21:39:01+00:00",
+    "source_file": "4-Classification/2-Classifiers-1/README.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/2-Classifiers-1/assignment.md": {
+    "original_hash": "de6025f96841498b0577e9d1aee18d1f",
+    "translation_date": "2025-08-29T21:44:33+00:00",
+    "source_file": "4-Classification/2-Classifiers-1/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/2-Classifiers-1/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T21:44:55+00:00",
+    "source_file": "4-Classification/2-Classifiers-1/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/3-Classifiers-2/README.md": {
+    "original_hash": "49047911108adc49d605cddfb455749c",
+    "translation_date": "2025-09-04T21:40:38+00:00",
+    "source_file": "4-Classification/3-Classifiers-2/README.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/3-Classifiers-2/assignment.md": {
+    "original_hash": "58dfdaf79fb73f7d34b22bdbacf57329",
+    "translation_date": "2025-08-29T21:50:29+00:00",
+    "source_file": "4-Classification/3-Classifiers-2/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/3-Classifiers-2/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T21:50:51+00:00",
+    "source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/4-Applied/README.md": {
+    "original_hash": "61bdec27ed2da8b098cd9065405d9bb0",
+    "translation_date": "2025-09-04T21:40:07+00:00",
+    "source_file": "4-Classification/4-Applied/README.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/4-Applied/assignment.md": {
+    "original_hash": "799ed651e2af0a7cad17c6268db11578",
+    "translation_date": "2025-08-29T21:48:02+00:00",
+    "source_file": "4-Classification/4-Applied/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "4-Classification/README.md": {
+    "original_hash": "74e809ffd1e613a1058bbc3e9600859e",
+    "translation_date": "2025-08-29T21:40:04+00:00",
+    "source_file": "4-Classification/README.md",
+    "language_code": "pt-BR"
+  },
+  "5-Clustering/1-Visualize/README.md": {
+    "original_hash": "730225ea274c9174fe688b21d421539d",
+    "translation_date": "2025-09-04T21:29:07+00:00",
+    "source_file": "5-Clustering/1-Visualize/README.md",
+    "language_code": "pt-BR"
+  },
+  "5-Clustering/1-Visualize/assignment.md": {
+    "original_hash": "589fa015a5e7d9e67bd629f7d47b53de",
+    "translation_date": "2025-08-29T21:04:33+00:00",
+    "source_file": "5-Clustering/1-Visualize/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "5-Clustering/1-Visualize/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T21:04:56+00:00",
+    "source_file": "5-Clustering/1-Visualize/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "5-Clustering/2-K-Means/README.md": {
+    "original_hash": "7cdd17338d9bbd7e2171c2cd462eb081",
+    "translation_date": "2025-09-04T21:30:41+00:00",
+    "source_file": "5-Clustering/2-K-Means/README.md",
+    "language_code": "pt-BR"
+  },
+  "5-Clustering/2-K-Means/assignment.md": {
+    "original_hash": "b8e17eff34ad1680eba2a5d3cf9ffc41",
+    "translation_date": "2025-08-29T21:07:38+00:00",
+    "source_file": "5-Clustering/2-K-Means/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "5-Clustering/2-K-Means/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T21:08:00+00:00",
+    "source_file": "5-Clustering/2-K-Means/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "5-Clustering/README.md": {
+    "original_hash": "b28a3a4911584062772c537b653ebbc7",
+    "translation_date": "2025-08-29T20:52:39+00:00",
+    "source_file": "5-Clustering/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/1-Introduction-to-NLP/README.md": {
+    "original_hash": "1c2ec40cf55c98a028a359c27ef7e45a",
+    "translation_date": "2025-09-04T21:45:46+00:00",
+    "source_file": "6-NLP/1-Introduction-to-NLP/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/1-Introduction-to-NLP/assignment.md": {
+    "original_hash": "1d7583e8046dacbb0c056d5ba0a71b16",
+    "translation_date": "2025-08-29T22:33:21+00:00",
+    "source_file": "6-NLP/1-Introduction-to-NLP/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/2-Tasks/README.md": {
+    "original_hash": "5f3cb462e3122e1afe7ab0050ccf2bd3",
+    "translation_date": "2025-09-04T21:43:59+00:00",
+    "source_file": "6-NLP/2-Tasks/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/2-Tasks/assignment.md": {
+    "original_hash": "2efc4c2aba5ed06c780c05539c492ae3",
+    "translation_date": "2025-08-29T22:21:35+00:00",
+    "source_file": "6-NLP/2-Tasks/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/3-Translation-Sentiment/README.md": {
+    "original_hash": "be03c8182982b87ced155e4e9d1438e8",
+    "translation_date": "2025-09-04T21:46:33+00:00",
+    "source_file": "6-NLP/3-Translation-Sentiment/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/3-Translation-Sentiment/assignment.md": {
+    "original_hash": "9d2a734deb904caff310d1a999c6bd7a",
+    "translation_date": "2025-08-29T22:38:26+00:00",
+    "source_file": "6-NLP/3-Translation-Sentiment/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/3-Translation-Sentiment/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T22:39:07+00:00",
+    "source_file": "6-NLP/3-Translation-Sentiment/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/3-Translation-Sentiment/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T22:38:51+00:00",
+    "source_file": "6-NLP/3-Translation-Sentiment/solution/R/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/4-Hotel-Reviews-1/README.md": {
+    "original_hash": "8d32dadeda93c6fb5c43619854882ab1",
+    "translation_date": "2025-09-04T21:44:36+00:00",
+    "source_file": "6-NLP/4-Hotel-Reviews-1/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/4-Hotel-Reviews-1/assignment.md": {
+    "original_hash": "bf39bceb833cd628f224941dca8041df",
+    "translation_date": "2025-08-29T22:29:04+00:00",
+    "source_file": "6-NLP/4-Hotel-Reviews-1/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T22:29:42+00:00",
+    "source_file": "6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/4-Hotel-Reviews-1/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T22:29:24+00:00",
+    "source_file": "6-NLP/4-Hotel-Reviews-1/solution/R/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/5-Hotel-Reviews-2/README.md": {
+    "original_hash": "2c742993fe95d5bcbb2846eda3d442a1",
+    "translation_date": "2025-09-04T21:47:17+00:00",
+    "source_file": "6-NLP/5-Hotel-Reviews-2/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/5-Hotel-Reviews-2/assignment.md": {
+    "original_hash": "daf144daa552da6a7d442aff6f3e77d8",
+    "translation_date": "2025-08-29T22:43:47+00:00",
+    "source_file": "6-NLP/5-Hotel-Reviews-2/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T22:44:24+00:00",
+    "source_file": "6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/5-Hotel-Reviews-2/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T22:44:08+00:00",
+    "source_file": "6-NLP/5-Hotel-Reviews-2/solution/R/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/README.md": {
+    "original_hash": "1eb379dc2d0c9940b320732d16083778",
+    "translation_date": "2025-08-29T22:17:54+00:00",
+    "source_file": "6-NLP/README.md",
+    "language_code": "pt-BR"
+  },
+  "6-NLP/data/README.md": {
+    "original_hash": "ee0670655c89e4719319764afb113624",
+    "translation_date": "2025-08-29T22:30:00+00:00",
+    "source_file": "6-NLP/data/README.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/1-Introduction/README.md": {
+    "original_hash": "662b509c39eee205687726636d0a8455",
+    "translation_date": "2025-09-04T21:27:37+00:00",
+    "source_file": "7-TimeSeries/1-Introduction/README.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/1-Introduction/assignment.md": {
+    "original_hash": "d1781b0b92568ea1d119d0a198b576b4",
+    "translation_date": "2025-08-29T20:48:05+00:00",
+    "source_file": "7-TimeSeries/1-Introduction/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/1-Introduction/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T20:48:45+00:00",
+    "source_file": "7-TimeSeries/1-Introduction/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/1-Introduction/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T20:48:28+00:00",
+    "source_file": "7-TimeSeries/1-Introduction/solution/R/README.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/2-ARIMA/README.md": {
+    "original_hash": "917dbf890db71a322f306050cb284749",
+    "translation_date": "2025-09-04T21:26:37+00:00",
+    "source_file": "7-TimeSeries/2-ARIMA/README.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/2-ARIMA/assignment.md": {
+    "original_hash": "1c814013e10866dfd92cdb32caaae3ac",
+    "translation_date": "2025-08-29T20:43:12+00:00",
+    "source_file": "7-TimeSeries/2-ARIMA/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/2-ARIMA/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T20:43:57+00:00",
+    "source_file": "7-TimeSeries/2-ARIMA/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/2-ARIMA/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T20:43:34+00:00",
+    "source_file": "7-TimeSeries/2-ARIMA/solution/R/README.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/3-SVR/README.md": {
+    "original_hash": "482bccabe1df958496ea71a3667995cd",
+    "translation_date": "2025-09-04T21:28:28+00:00",
+    "source_file": "7-TimeSeries/3-SVR/README.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/3-SVR/assignment.md": {
+    "original_hash": "94aa2fc6154252ae30a3f3740299707a",
+    "translation_date": "2025-08-29T20:51:43+00:00",
+    "source_file": "7-TimeSeries/3-SVR/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "7-TimeSeries/README.md": {
+    "original_hash": "61342603bad8acadbc6b2e4e3aab3f66",
+    "translation_date": "2025-08-29T20:38:37+00:00",
+    "source_file": "7-TimeSeries/README.md",
+    "language_code": "pt-BR"
+  },
+  "8-Reinforcement/1-QLearning/README.md": {
+    "original_hash": "911efd5e595089000cb3c16fce1beab8",
+    "translation_date": "2025-09-04T21:42:23+00:00",
+    "source_file": "8-Reinforcement/1-QLearning/README.md",
+    "language_code": "pt-BR"
+  },
+  "8-Reinforcement/1-QLearning/assignment.md": {
+    "original_hash": "68394b2102d3503882e5e914bd0ff5c1",
+    "translation_date": "2025-08-29T22:10:51+00:00",
+    "source_file": "8-Reinforcement/1-QLearning/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "8-Reinforcement/1-QLearning/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T22:11:50+00:00",
+    "source_file": "8-Reinforcement/1-QLearning/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "8-Reinforcement/1-QLearning/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T22:11:34+00:00",
+    "source_file": "8-Reinforcement/1-QLearning/solution/R/README.md",
+    "language_code": "pt-BR"
+  },
+  "8-Reinforcement/2-Gym/README.md": {
+    "original_hash": "107d5bb29da8a562e7ae72262d251a75",
+    "translation_date": "2025-09-04T21:43:14+00:00",
+    "source_file": "8-Reinforcement/2-Gym/README.md",
+    "language_code": "pt-BR"
+  },
+  "8-Reinforcement/2-Gym/assignment.md": {
+    "original_hash": "1f2b7441745eb52e25745423b247016b",
+    "translation_date": "2025-08-29T22:16:29+00:00",
+    "source_file": "8-Reinforcement/2-Gym/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "8-Reinforcement/2-Gym/solution/Julia/README.md": {
+    "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+    "translation_date": "2025-08-29T22:17:19+00:00",
+    "source_file": "8-Reinforcement/2-Gym/solution/Julia/README.md",
+    "language_code": "pt-BR"
+  },
+  "8-Reinforcement/2-Gym/solution/R/README.md": {
+    "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+    "translation_date": "2025-08-29T22:17:02+00:00",
+    "source_file": "8-Reinforcement/2-Gym/solution/R/README.md",
+    "language_code": "pt-BR"
+  },
+  "8-Reinforcement/README.md": {
+    "original_hash": "20ca019012b1725de956681d036d8b18",
+    "translation_date": "2025-08-29T22:02:32+00:00",
+    "source_file": "8-Reinforcement/README.md",
+    "language_code": "pt-BR"
+  },
+  "9-Real-World/1-Applications/README.md": {
+    "original_hash": "83320d6b6994909e35d830cebf214039",
+    "translation_date": "2025-09-04T21:31:29+00:00",
+    "source_file": "9-Real-World/1-Applications/README.md",
+    "language_code": "pt-BR"
+  },
+  "9-Real-World/1-Applications/assignment.md": {
+    "original_hash": "fdebfcd0a3f12c9e2b436ded1aa79885",
+    "translation_date": "2025-08-29T21:14:07+00:00",
+    "source_file": "9-Real-World/1-Applications/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "9-Real-World/2-Debugging-ML-Models/README.md": {
+    "original_hash": "df2b538e8fbb3e91cf0419ae2f858675",
+    "translation_date": "2025-09-04T21:32:46+00:00",
+    "source_file": "9-Real-World/2-Debugging-ML-Models/README.md",
+    "language_code": "pt-BR"
+  },
+  "9-Real-World/2-Debugging-ML-Models/assignment.md": {
+    "original_hash": "91c6a180ef08e20cc15acfd2d6d6e164",
+    "translation_date": "2025-08-29T21:18:53+00:00",
+    "source_file": "9-Real-World/2-Debugging-ML-Models/assignment.md",
+    "language_code": "pt-BR"
+  },
+  "9-Real-World/README.md": {
+    "original_hash": "5e069a0ac02a9606a69946c2b3c574a9",
+    "translation_date": "2025-08-29T21:09:28+00:00",
+    "source_file": "9-Real-World/README.md",
+    "language_code": "pt-BR"
+  },
+  "AGENTS.md": {
+    "original_hash": "93fdaa0fd38836e50c4793e2f2f25e8b",
+    "translation_date": "2025-10-03T11:06:33+00:00",
+    "source_file": "AGENTS.md",
+    "language_code": "pt-BR"
+  },
+  "CODE_OF_CONDUCT.md": {
+    "original_hash": "c06b12caf3c901eb3156e3dd5b0aea56",
+    "translation_date": "2025-08-29T20:12:34+00:00",
+    "source_file": "CODE_OF_CONDUCT.md",
+    "language_code": "pt-BR"
+  },
+  "CONTRIBUTING.md": {
+    "original_hash": "977ec5266dfd78ad1ce2bd8d46fccbda",
+    "translation_date": "2025-08-29T20:10:18+00:00",
+    "source_file": "CONTRIBUTING.md",
+    "language_code": "pt-BR"
+  },
+  "README.md": {
+    "original_hash": "da2ceed62f16a0820259556e3a873c95",
+    "translation_date": "2026-01-29T18:20:17+00:00",
+    "source_file": "README.md",
+    "language_code": "pt-BR"
+  },
+  "SECURITY.md": {
+    "original_hash": "5e1b8da31aae9cca3d53ad243fa3365a",
+    "translation_date": "2025-08-29T20:11:06+00:00",
+    "source_file": "SECURITY.md",
+    "language_code": "pt-BR"
+  },
+  "SUPPORT.md": {
+    "original_hash": "09623d7343ff1c26ff4f198c1b2d3176",
+    "translation_date": "2025-10-03T11:57:42+00:00",
+    "source_file": "SUPPORT.md",
+    "language_code": "pt-BR"
+  },
+  "TROUBLESHOOTING.md": {
+    "original_hash": "134d8759f0e2ab886e9aa4f62362c201",
+    "translation_date": "2025-10-03T12:44:07+00:00",
+    "source_file": "TROUBLESHOOTING.md",
+    "language_code": "pt-BR"
+  },
+  "docs/_sidebar.md": {
+    "original_hash": "68dd06c685f6ce840e0acfa313352e7c",
+    "translation_date": "2025-08-29T21:08:41+00:00",
+    "source_file": "docs/_sidebar.md",
+    "language_code": "pt-BR"
+  },
+  "for-teachers.md": {
+    "original_hash": "b37de02054fa6c0438ede6fabe1fdfb8",
+    "translation_date": "2025-08-29T20:11:59+00:00",
+    "source_file": "for-teachers.md",
+    "language_code": "pt-BR"
+  },
+  "quiz-app/README.md": {
+    "original_hash": "6d130dffca5db70d7e615f926cb1ad4c",
+    "translation_date": "2025-08-29T21:39:09+00:00",
+    "source_file": "quiz-app/README.md",
+    "language_code": "pt-BR"
+  },
+  "sketchnotes/LICENSE.md": {
+    "original_hash": "fba3b94d88bfb9b81369b869a1e9a20f",
+    "translation_date": "2025-08-29T21:59:36+00:00",
+    "source_file": "sketchnotes/LICENSE.md",
+    "language_code": "pt-BR"
+  },
+  "sketchnotes/README.md": {
+    "original_hash": "a88d5918c1b9da69a40d917a0840c497",
+    "translation_date": "2025-08-29T21:54:55+00:00",
+    "source_file": "sketchnotes/README.md",
+    "language_code": "pt-BR"
+  }
+}

translations/pt-BR/1-Introduction/1-intro-to-ML/README.md

@@ -0,0 +1,150 @@
+# Introdução ao aprendizado de máquina
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+
+[![ML para iniciantes - Introdução ao Aprendizado de Máquina para Iniciantes](https://img.youtube.com/vi/6mSx_KJxcHI/0.jpg)](https://youtu.be/6mSx_KJxcHI "ML para iniciantes - Introdução ao Aprendizado de Máquina para Iniciantes")
+
+> 🎥 Clique na imagem acima para assistir a um vídeo curto sobre esta lição.
+
+Bem-vindo a este curso sobre aprendizado de máquina clássico para iniciantes! Seja você completamente novo neste tópico ou um praticante experiente de ML buscando revisar alguma área, estamos felizes em tê-lo conosco! Queremos criar um ponto de partida amigável para seus estudos de ML e ficaremos felizes em avaliar, responder e incorporar seu [feedback](https://github.com/microsoft/ML-For-Beginners/discussions).
+
+[![Introdução ao ML](https://img.youtube.com/vi/h0e2HAPTGF4/0.jpg)](https://youtu.be/h0e2HAPTGF4 "Introdução ao ML")
+
+> 🎥 Clique na imagem acima para assistir a um vídeo: John Guttag do MIT apresenta aprendizado de máquina.
+
+---
+## Começando com aprendizado de máquina
+
+Antes de começar com este currículo, você precisa configurar seu computador e estar pronto para executar notebooks localmente.
+
+- **Configure sua máquina com estes vídeos**. Use os links a seguir para aprender [como instalar Python](https://youtu.be/CXZYvNRIAKM) no seu sistema e [configurar um editor de texto](https://youtu.be/EU8eayHWoZg) para desenvolvimento.
+- **Aprenda Python**. Também é recomendado ter um entendimento básico de [Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), uma linguagem de programação útil para cientistas de dados que utilizamos neste curso.
+- **Aprenda Node.js e JavaScript**. Também utilizamos JavaScript algumas vezes neste curso ao construir aplicativos web, então você precisará ter [node](https://nodejs.org) e [npm](https://www.npmjs.com/) instalados, além de [Visual Studio Code](https://code.visualstudio.com/) disponível para desenvolvimento em Python e JavaScript.
+- **Crie uma conta no GitHub**. Já que você nos encontrou aqui no [GitHub](https://github.com), talvez já tenha uma conta, mas se não, crie uma e depois faça um fork deste currículo para usar por conta própria. (Sinta-se à vontade para nos dar uma estrela também 😊)
+- **Explore o Scikit-learn**. Familiarize-se com [Scikit-learn](https://scikit-learn.org/stable/user_guide.html), um conjunto de bibliotecas de ML que referenciamos nestas lições.
+
+---
+## O que é aprendizado de máquina?
+
+O termo 'aprendizado de máquina' é um dos mais populares e frequentemente usados atualmente. Existe uma possibilidade não trivial de que você já tenha ouvido este termo pelo menos uma vez, caso tenha algum tipo de familiaridade com tecnologia, independentemente da área em que trabalha. No entanto, a mecânica do aprendizado de máquina é um mistério para a maioria das pessoas. Para um iniciante em aprendizado de máquina, o assunto pode às vezes parecer intimidante. Portanto, é importante entender o que realmente é aprendizado de máquina e aprender sobre ele passo a passo, por meio de exemplos práticos.
+
+---
+## A curva de hype
+
+![ml hype curve](../../../../1-Introduction/1-intro-to-ML/images/hype.png)
+
+> O Google Trends mostra a recente 'curva de hype' do termo 'aprendizado de máquina'
+
+---
+## Um universo misterioso
+
+Vivemos em um universo cheio de mistérios fascinantes. Grandes cientistas como Stephen Hawking, Albert Einstein e muitos outros dedicaram suas vidas à busca de informações significativas que desvendassem os mistérios do mundo ao nosso redor. Esta é a condição humana de aprender: uma criança humana aprende coisas novas e descobre a estrutura de seu mundo ano após ano enquanto cresce até a idade adulta.
+
+---
+## O cérebro da criança
+
+O cérebro e os sentidos de uma criança percebem os fatos ao seu redor e gradualmente aprendem os padrões ocultos da vida, que ajudam a criança a criar regras lógicas para identificar padrões aprendidos. O processo de aprendizado do cérebro humano torna os humanos as criaturas mais sofisticadas deste mundo. Aprender continuamente, descobrindo padrões ocultos e depois inovando com base nesses padrões, nos permite melhorar continuamente ao longo de nossas vidas. Essa capacidade de aprendizado e evolução está relacionada a um conceito chamado [plasticidade cerebral](https://www.simplypsychology.org/brain-plasticity.html). Superficialmente, podemos traçar algumas semelhanças motivacionais entre o processo de aprendizado do cérebro humano e os conceitos de aprendizado de máquina.
+
+---
+## O cérebro humano
+
+O [cérebro humano](https://www.livescience.com/29365-human-brain.html) percebe coisas do mundo real, processa as informações percebidas, toma decisões racionais e realiza certas ações com base nas circunstâncias. Isso é o que chamamos de comportamento inteligente. Quando programamos uma réplica do processo de comportamento inteligente em uma máquina, isso é chamado de inteligência artificial (IA).
+
+---
+## Alguns termos
+
+Embora os termos possam ser confundidos, aprendizado de máquina (ML) é um subconjunto importante da inteligência artificial. **ML está relacionado ao uso de algoritmos especializados para descobrir informações significativas e encontrar padrões ocultos a partir de dados percebidos, corroborando o processo de tomada de decisão racional**.
+
+---
+## IA, ML, Aprendizado Profundo
+
+![AI, ML, deep learning, data science](../../../../1-Introduction/1-intro-to-ML/images/ai-ml-ds.png)
+
+> Um diagrama mostrando as relações entre IA, ML, aprendizado profundo e ciência de dados. Infográfico por [Jen Looper](https://twitter.com/jenlooper) inspirado por [este gráfico](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining)
+
+---
+## Conceitos abordados
+
+Neste currículo, vamos abordar apenas os conceitos principais de aprendizado de máquina que um iniciante deve conhecer. Abordamos o que chamamos de 'aprendizado de máquina clássico', principalmente usando Scikit-learn, uma excelente biblioteca que muitos estudantes utilizam para aprender o básico. Para entender conceitos mais amplos de inteligência artificial ou aprendizado profundo, um conhecimento fundamental sólido de aprendizado de máquina é indispensável, e é isso que queremos oferecer aqui.
+
+---
+## Neste curso você aprenderá:
+
+- conceitos principais de aprendizado de máquina
+- a história do ML
+- ML e justiça
+- técnicas de regressão em ML
+- técnicas de classificação em ML
+- técnicas de agrupamento em ML
+- técnicas de processamento de linguagem natural em ML
+- técnicas de previsão de séries temporais em ML
+- aprendizado por reforço
+- aplicações reais de ML
+
+---
+## O que não abordaremos
+
+- aprendizado profundo
+- redes neurais
+- IA
+
+Para proporcionar uma melhor experiência de aprendizado, evitaremos as complexidades de redes neurais, 'aprendizado profundo' - construção de modelos com muitas camadas usando redes neurais - e IA, que discutiremos em um currículo diferente. Também ofereceremos um futuro currículo de ciência de dados para focar nesse aspecto deste campo maior.
+
+---
+## Por que estudar aprendizado de máquina?
+
+Aprendizado de máquina, de uma perspectiva de sistemas, é definido como a criação de sistemas automatizados que podem aprender padrões ocultos a partir de dados para ajudar na tomada de decisões inteligentes.
+
+Essa motivação é vagamente inspirada por como o cérebro humano aprende certas coisas com base nos dados que percebe do mundo exterior.
+
+✅ Pense por um momento por que uma empresa gostaria de usar estratégias de aprendizado de máquina em vez de criar um mecanismo baseado em regras codificadas.
+
+---
+## Aplicações do aprendizado de máquina
+
+As aplicações do aprendizado de máquina estão agora quase em todos os lugares e são tão onipresentes quanto os dados que circulam em nossas sociedades, gerados por nossos smartphones, dispositivos conectados e outros sistemas. Considerando o imenso potencial dos algoritmos de aprendizado de máquina de última geração, pesquisadores têm explorado sua capacidade de resolver problemas reais multidimensionais e multidisciplinares com ótimos resultados positivos.
+
+---
+## Exemplos de ML aplicado
+
+**Você pode usar aprendizado de máquina de várias maneiras**:
+
+- Para prever a probabilidade de uma doença com base no histórico médico ou relatórios de um paciente.
+- Para aproveitar dados meteorológicos e prever eventos climáticos.
+- Para entender o sentimento de um texto.
+- Para detectar notícias falsas e impedir a propagação de propaganda.
+
+Finanças, economia, ciência da terra, exploração espacial, engenharia biomédica, ciência cognitiva e até mesmo áreas das humanidades têm adaptado o aprendizado de máquina para resolver os problemas árduos e pesados em processamento de dados de seus domínios.
+
+---
+## Conclusão
+
+O aprendizado de máquina automatiza o processo de descoberta de padrões ao encontrar insights significativos a partir de dados reais ou gerados. Ele tem se mostrado altamente valioso em aplicações de negócios, saúde e finanças, entre outras.
+
+No futuro próximo, entender os fundamentos do aprendizado de máquina será essencial para pessoas de qualquer área devido à sua ampla adoção.
+
+---
+# 🚀 Desafio
+
+Desenhe, no papel ou usando um aplicativo online como [Excalidraw](https://excalidraw.com/), sua compreensão das diferenças entre IA, ML, aprendizado profundo e ciência de dados. Adicione algumas ideias de problemas que cada uma dessas técnicas é boa em resolver.
+
+# [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+# Revisão e Autoestudo
+
+Para aprender mais sobre como trabalhar com algoritmos de ML na nuvem, siga este [Caminho de Aprendizado](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-77952-leestott).
+
+Faça um [Caminho de Aprendizado](https://docs.microsoft.com/learn/modules/introduction-to-machine-learning/?WT.mc_id=academic-77952-leestott) sobre os fundamentos de ML.
+
+---
+# Tarefa
+
+[Prepare-se e comece](assignment.md)
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/1-Introduction/1-intro-to-ML/assignment.md

@@ -0,0 +1,14 @@
+# Comece a Trabalhar
+
+## Instruções
+
+Nesta atividade não avaliada, você deve revisar seus conhecimentos em Python e configurar seu ambiente para executar notebooks.
+
+Siga este [Caminho de Aprendizado em Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott) e, em seguida, configure seus sistemas assistindo a estes vídeos introdutórios:
+
+https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/1-Introduction/2-history-of-ML/README.md

@@ -0,0 +1,155 @@
+# História do aprendizado de máquina
+
+![Resumo da história do aprendizado de máquina em um sketchnote](../../../../sketchnotes/ml-history.png)
+> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+
+[![ML para iniciantes - História do aprendizado de máquina](https://img.youtube.com/vi/N6wxM4wZ7V0/0.jpg)](https://youtu.be/N6wxM4wZ7V0 "ML para iniciantes - História do aprendizado de máquina")
+
+> 🎥 Clique na imagem acima para assistir a um vídeo curto sobre esta lição.
+
+Nesta lição, vamos explorar os principais marcos na história do aprendizado de máquina e da inteligência artificial.
+
+A história da inteligência artificial (IA) como campo está entrelaçada com a história do aprendizado de máquina, já que os algoritmos e avanços computacionais que sustentam o aprendizado de máquina contribuíram para o desenvolvimento da IA. É útil lembrar que, embora esses campos como áreas distintas de estudo tenham começado a se cristalizar na década de 1950, importantes [descobertas algorítmicas, estatísticas, matemáticas, computacionais e técnicas](https://wikipedia.org/wiki/Timeline_of_machine_learning) precederam e se sobrepuseram a essa era. Na verdade, as pessoas têm pensado sobre essas questões por [centenas de anos](https://wikipedia.org/wiki/History_of_artificial_intelligence): este artigo discute as bases intelectuais históricas da ideia de uma 'máquina pensante'.
+
+---
+## Descobertas notáveis
+
+- 1763, 1812 [Teorema de Bayes](https://wikipedia.org/wiki/Bayes%27_theorem) e seus predecessores. Este teorema e suas aplicações fundamentam a inferência, descrevendo a probabilidade de um evento ocorrer com base em conhecimento prévio.
+- 1805 [Teoria dos Mínimos Quadrados](https://wikipedia.org/wiki/Least_squares) pelo matemático francês Adrien-Marie Legendre. Esta teoria, que você aprenderá em nossa unidade de regressão, ajuda no ajuste de dados.
+- 1913 [Cadeias de Markov](https://wikipedia.org/wiki/Markov_chain), nomeadas em homenagem ao matemático russo Andrey Markov, são usadas para descrever uma sequência de eventos possíveis com base em um estado anterior.
+- 1957 [Perceptron](https://wikipedia.org/wiki/Perceptron) é um tipo de classificador linear inventado pelo psicólogo americano Frank Rosenblatt que fundamenta avanços em aprendizado profundo.
+
+---
+
+- 1967 [Vizinho Mais Próximo](https://wikipedia.org/wiki/Nearest_neighbor) é um algoritmo originalmente projetado para mapear rotas. No contexto de aprendizado de máquina, é usado para detectar padrões.
+- 1970 [Retropropagação](https://wikipedia.org/wiki/Backpropagation) é usada para treinar [redes neurais feedforward](https://wikipedia.org/wiki/Feedforward_neural_network).
+- 1982 [Redes Neurais Recorrentes](https://wikipedia.org/wiki/Recurrent_neural_network) são redes neurais artificiais derivadas de redes neurais feedforward que criam gráficos temporais.
+
+✅ Faça uma pequena pesquisa. Quais outras datas se destacam como marcos na história do aprendizado de máquina e da IA?
+
+---
+## 1950: Máquinas que pensam
+
+Alan Turing, uma pessoa verdadeiramente notável que foi eleito [pelo público em 2019](https://wikipedia.org/wiki/Icons:_The_Greatest_Person_of_the_20th_Century) como o maior cientista do século 20, é creditado por ajudar a estabelecer as bases para o conceito de uma 'máquina que pode pensar'. Ele enfrentou críticos e sua própria necessidade de evidências empíricas desse conceito, em parte, criando o [Teste de Turing](https://www.bbc.com/news/technology-18475646), que você explorará em nossas lições de PLN.
+
+---
+## 1956: Projeto de Pesquisa de Verão em Dartmouth
+
+"O Projeto de Pesquisa de Verão em Dartmouth sobre inteligência artificial foi um evento seminal para a inteligência artificial como campo", e foi aqui que o termo 'inteligência artificial' foi cunhado ([fonte](https://250.dartmouth.edu/highlights/artificial-intelligence-ai-coined-dartmouth)).
+
+> Todo aspecto de aprendizado ou qualquer outra característica da inteligência pode, em princípio, ser descrito tão precisamente que uma máquina pode ser feita para simulá-lo.
+
+---
+
+O pesquisador principal, o professor de matemática John McCarthy, esperava "prosseguir com base na conjectura de que todo aspecto de aprendizado ou qualquer outra característica da inteligência pode, em princípio, ser descrito tão precisamente que uma máquina pode ser feita para simulá-lo." Os participantes incluíram outro grande nome do campo, Marvin Minsky.
+
+O workshop é creditado por ter iniciado e incentivado várias discussões, incluindo "a ascensão de métodos simbólicos, sistemas focados em domínios limitados (primeiros sistemas especialistas) e sistemas dedutivos versus sistemas indutivos." ([fonte](https://wikipedia.org/wiki/Dartmouth_workshop)).
+
+---
+## 1956 - 1974: "Os anos dourados"
+
+Dos anos 1950 até meados dos anos 70, o otimismo era alto na esperança de que a IA pudesse resolver muitos problemas. Em 1967, Marvin Minsky afirmou confiantemente que "Dentro de uma geração... o problema de criar 'inteligência artificial' será substancialmente resolvido." (Minsky, Marvin (1967), Computation: Finite and Infinite Machines, Englewood Cliffs, N.J.: Prentice-Hall)
+
+Pesquisas em processamento de linguagem natural floresceram, buscas foram refinadas e tornadas mais poderosas, e o conceito de 'micro-mundos' foi criado, onde tarefas simples eram realizadas usando instruções em linguagem comum.
+
+---
+
+A pesquisa foi bem financiada por agências governamentais, avanços foram feitos em computação e algoritmos, e protótipos de máquinas inteligentes foram construídos. Algumas dessas máquinas incluem:
+
+* [Shakey, o robô](https://wikipedia.org/wiki/Shakey_the_robot), que podia se mover e decidir como realizar tarefas 'inteligentemente'.
+
+    ![Shakey, um robô inteligente](../../../../1-Introduction/2-history-of-ML/images/shakey.jpg)
+    > Shakey em 1972
+
+---
+
+* Eliza, um dos primeiros 'chatterbots', podia conversar com pessoas e agir como um 'terapeuta' primitivo. Você aprenderá mais sobre Eliza nas lições de PLN.
+
+    ![Eliza, um bot](../../../../1-Introduction/2-history-of-ML/images/eliza.png)
+    > Uma versão de Eliza, um chatbot
+
+---
+
+* "Blocks world" foi um exemplo de micro-mundo onde blocos podiam ser empilhados e organizados, e experimentos em ensinar máquinas a tomar decisões podiam ser testados. Avanços construídos com bibliotecas como [SHRDLU](https://wikipedia.org/wiki/SHRDLU) ajudaram a impulsionar o processamento de linguagem.
+
+    [![blocks world com SHRDLU](https://img.youtube.com/vi/QAJz4YKUwqw/0.jpg)](https://www.youtube.com/watch?v=QAJz4YKUwqw "blocks world com SHRDLU")
+
+    > 🎥 Clique na imagem acima para assistir a um vídeo: Blocks world com SHRDLU
+
+---
+## 1974 - 1980: "Inverno da IA"
+
+Por volta de meados dos anos 1970, tornou-se evidente que a complexidade de criar 'máquinas inteligentes' havia sido subestimada e que sua promessa, dada a capacidade computacional disponível, havia sido exagerada. O financiamento secou e a confiança no campo diminuiu. Alguns problemas que impactaram a confiança incluíram:
+---
+- **Limitações**. A capacidade computacional era muito limitada.
+- **Explosão combinatória**. A quantidade de parâmetros necessários para treinamento cresceu exponencialmente à medida que mais era exigido dos computadores, sem uma evolução paralela da capacidade computacional.
+- **Escassez de dados**. Havia uma escassez de dados que dificultava o processo de teste, desenvolvimento e refinamento de algoritmos.
+- **Estamos fazendo as perguntas certas?**. As próprias perguntas que estavam sendo feitas começaram a ser questionadas. Pesquisadores começaram a enfrentar críticas sobre suas abordagens:
+  - Testes de Turing foram questionados por meio, entre outras ideias, da 'teoria da sala chinesa', que postulava que "programar um computador digital pode fazê-lo parecer entender a linguagem, mas não poderia produzir compreensão real." ([fonte](https://plato.stanford.edu/entries/chinese-room/))
+  - A ética de introduzir inteligências artificiais como o "terapeuta" ELIZA na sociedade foi desafiada.
+
+---
+
+Ao mesmo tempo, várias escolas de pensamento em IA começaram a se formar. Uma dicotomia foi estabelecida entre práticas de ["IA desleixada" vs. "IA organizada"](https://wikipedia.org/wiki/Neats_and_scruffies). Laboratórios _desleixados_ ajustavam programas por horas até obterem os resultados desejados. Laboratórios _organizados_ "focavam em lógica e resolução formal de problemas". ELIZA e SHRDLU eram sistemas _desleixados_ bem conhecidos. Nos anos 1980, à medida que surgiu a demanda por sistemas de aprendizado de máquina reproduzíveis, a abordagem _organizada_ gradualmente tomou a dianteira, pois seus resultados são mais explicáveis.
+
+---
+## Sistemas especialistas nos anos 1980
+
+À medida que o campo crescia, seus benefícios para os negócios tornaram-se mais claros, e nos anos 1980 também ocorreu a proliferação de 'sistemas especialistas'. "Sistemas especialistas estavam entre as primeiras formas verdadeiramente bem-sucedidas de software de inteligência artificial (IA)." ([fonte](https://wikipedia.org/wiki/Expert_system)).
+
+Este tipo de sistema é na verdade _híbrido_, consistindo parcialmente de um motor de regras que define requisitos de negócios e um motor de inferência que utiliza o sistema de regras para deduzir novos fatos.
+
+Esta era também viu uma atenção crescente às redes neurais.
+
+---
+## 1987 - 1993: "Resfriamento da IA"
+
+A proliferação de hardware especializado para sistemas especialistas teve o efeito infeliz de se tornar muito especializado. O surgimento dos computadores pessoais também competiu com esses sistemas grandes, especializados e centralizados. A democratização da computação havia começado, e isso eventualmente abriu caminho para a explosão moderna de big data.
+
+---
+## 1993 - 2011
+
+Este período viu uma nova era para o aprendizado de máquina e a IA, permitindo resolver alguns dos problemas causados anteriormente pela falta de dados e capacidade computacional. A quantidade de dados começou a aumentar rapidamente e se tornar mais amplamente disponível, para o bem e para o mal, especialmente com o advento do smartphone por volta de 2007. A capacidade computacional expandiu exponencialmente, e os algoritmos evoluíram junto. O campo começou a ganhar maturidade à medida que os dias livres do passado começaram a se cristalizar em uma verdadeira disciplina.
+
+---
+## Hoje
+
+Hoje, o aprendizado de máquina e a IA tocam quase todas as partes de nossas vidas. Esta era exige uma compreensão cuidadosa dos riscos e dos potenciais efeitos desses algoritmos na vida humana. Como Brad Smith, da Microsoft, afirmou: "A tecnologia da informação levanta questões que vão ao cerne das proteções fundamentais dos direitos humanos, como privacidade e liberdade de expressão. Essas questões aumentam a responsabilidade das empresas de tecnologia que criam esses produtos. Em nossa visão, elas também exigem uma regulamentação governamental cuidadosa e o desenvolvimento de normas sobre usos aceitáveis" ([fonte](https://www.technologyreview.com/2019/12/18/102365/the-future-of-ais-impact-on-society/)).
+
+---
+
+Ainda não se sabe o que o futuro reserva, mas é importante entender esses sistemas computacionais e o software e os algoritmos que eles executam. Esperamos que este currículo ajude você a obter uma melhor compreensão para que possa decidir por si mesmo.
+
+[![A história do aprendizado profundo](https://img.youtube.com/vi/mTtDfKgLm54/0.jpg)](https://www.youtube.com/watch?v=mTtDfKgLm54 "A história do aprendizado profundo")
+> 🎥 Clique na imagem acima para assistir a um vídeo: Yann LeCun discute a história do aprendizado profundo nesta palestra
+
+---
+## 🚀Desafio
+
+Aprofunde-se em um desses momentos históricos e aprenda mais sobre as pessoas por trás deles. Há personagens fascinantes, e nenhuma descoberta científica foi criada em um vácuo cultural. O que você descobre?
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+## Revisão e autoestudo
+
+Aqui estão itens para assistir e ouvir:
+
+[Este podcast onde Amy Boyd discute a evolução da IA](http://runasradio.com/Shows/Show/739)
+
+[![A história da IA por Amy Boyd](https://img.youtube.com/vi/EJt3_bFYKss/0.jpg)](https://www.youtube.com/watch?v=EJt3_bFYKss "A história da IA por Amy Boyd")
+
+---
+
+## Tarefa
+
+[Criar uma linha do tempo](assignment.md)
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/1-Introduction/2-history-of-ML/assignment.md

@@ -0,0 +1,16 @@
+# Criar uma linha do tempo
+
+## Instruções
+
+Usando [este repositório](https://github.com/Digital-Humanities-Toolkit/timeline-builder), crie uma linha do tempo sobre algum aspecto da história dos algoritmos, matemática, estatística, IA ou ML, ou uma combinação desses temas. Você pode focar em uma pessoa, uma ideia ou um longo período de pensamento. Certifique-se de adicionar elementos multimídia.
+
+## Rubrica
+
+| Critérios | Exemplares                                         | Adequado                                | Precisa de Melhorias                                             |
+| --------- | -------------------------------------------------- | --------------------------------------- | ---------------------------------------------------------------- |
+|           | Uma linha do tempo implantada é apresentada como uma página do GitHub | O código está incompleto e não foi implantado | A linha do tempo está incompleta, não bem pesquisada e não foi implantada |
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/1-Introduction/3-fairness/README.md

@@ -0,0 +1,161 @@
+# Construindo soluções de Machine Learning com IA responsável
+
+![Resumo de IA responsável em Machine Learning em um sketchnote](../../../../sketchnotes/ml-fairness.png)
+> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+## Introdução
+
+Neste currículo, você começará a descobrir como o aprendizado de máquina pode impactar e já está impactando nossas vidas cotidianas. Atualmente, sistemas e modelos estão envolvidos em tarefas de tomada de decisão diária, como diagnósticos de saúde, aprovações de empréstimos ou detecção de fraudes. Por isso, é importante que esses modelos funcionem bem para fornecer resultados confiáveis. Assim como qualquer aplicação de software, sistemas de IA podem não atender às expectativas ou ter resultados indesejáveis. É por isso que é essencial entender e explicar o comportamento de um modelo de IA.
+
+Imagine o que pode acontecer quando os dados usados para construir esses modelos carecem de certos grupos demográficos, como raça, gênero, visão política, religião, ou representam esses grupos de forma desproporcional. E se a saída do modelo for interpretada de forma a favorecer algum grupo demográfico? Qual é a consequência para a aplicação? Além disso, o que acontece quando o modelo tem um resultado adverso e prejudica pessoas? Quem é responsável pelo comportamento dos sistemas de IA? Estas são algumas das questões que exploraremos neste currículo.
+
+Nesta lição, você irá:
+
+- Aumentar sua conscientização sobre a importância da equidade no aprendizado de máquina e os danos relacionados à falta de equidade.
+- Familiarizar-se com a prática de explorar outliers e cenários incomuns para garantir confiabilidade e segurança.
+- Compreender a necessidade de capacitar todos ao projetar sistemas inclusivos.
+- Explorar como é vital proteger a privacidade e a segurança dos dados e das pessoas.
+- Ver a importância de ter uma abordagem transparente para explicar o comportamento dos modelos de IA.
+- Ser consciente de como a responsabilidade é essencial para construir confiança em sistemas de IA.
+
+## Pré-requisito
+
+Como pré-requisito, faça o "Caminho de Aprendizado sobre Princípios de IA Responsável" e assista ao vídeo abaixo sobre o tema:
+
+Saiba mais sobre IA Responsável seguindo este [Caminho de Aprendizado](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott)
+
+[![Abordagem da Microsoft para IA Responsável](https://img.youtube.com/vi/dnC8-uUZXSc/0.jpg)](https://youtu.be/dnC8-uUZXSc "Abordagem da Microsoft para IA Responsável")
+
+> 🎥 Clique na imagem acima para assistir ao vídeo: Abordagem da Microsoft para IA Responsável
+
+## Equidade
+
+Sistemas de IA devem tratar todos de forma justa e evitar afetar grupos semelhantes de pessoas de maneiras diferentes. Por exemplo, quando sistemas de IA fornecem orientações sobre tratamento médico, solicitações de empréstimos ou emprego, eles devem fazer as mesmas recomendações para todos com sintomas, circunstâncias financeiras ou qualificações profissionais semelhantes. Cada um de nós, como seres humanos, carrega preconceitos herdados que afetam nossas decisões e ações. Esses preconceitos podem estar evidentes nos dados que usamos para treinar sistemas de IA. Essa manipulação pode, às vezes, acontecer de forma não intencional. Muitas vezes, é difícil perceber conscientemente quando você está introduzindo preconceitos nos dados.
+
+**“Injustiça”** abrange impactos negativos, ou “danos”, para um grupo de pessoas, como aqueles definidos em termos de raça, gênero, idade ou status de deficiência. Os principais danos relacionados à equidade podem ser classificados como:
+
+- **Alocação**, quando, por exemplo, um gênero ou etnia é favorecido em detrimento de outro.
+- **Qualidade do serviço**. Se você treinar os dados para um cenário específico, mas a realidade for muito mais complexa, isso leva a um serviço de desempenho ruim. Por exemplo, um dispensador de sabão que não consegue detectar pessoas com pele escura. [Referência](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
+- **Denigração**. Criticar ou rotular algo ou alguém de forma injusta. Por exemplo, uma tecnologia de rotulagem de imagens que infamemente rotulou imagens de pessoas de pele escura como gorilas.
+- **Super ou sub-representação**. A ideia de que um determinado grupo não é visto em uma certa profissão, e qualquer serviço ou função que continue promovendo isso está contribuindo para o dano.
+- **Estereotipagem**. Associar um grupo específico a atributos pré-definidos. Por exemplo, um sistema de tradução entre inglês e turco pode ter imprecisões devido a palavras com associações estereotipadas de gênero.
+
+![tradução para turco](../../../../1-Introduction/3-fairness/images/gender-bias-translate-en-tr.png)
+> tradução para turco
+
+![tradução de volta para inglês](../../../../1-Introduction/3-fairness/images/gender-bias-translate-tr-en.png)
+> tradução de volta para inglês
+
+Ao projetar e testar sistemas de IA, precisamos garantir que a IA seja justa e não programada para tomar decisões tendenciosas ou discriminatórias, que também são proibidas para seres humanos. Garantir equidade em IA e aprendizado de máquina continua sendo um desafio sociotécnico complexo.
+
+### Confiabilidade e segurança
+
+Para construir confiança, sistemas de IA precisam ser confiáveis, seguros e consistentes em condições normais e inesperadas. É importante saber como os sistemas de IA se comportarão em uma variedade de situações, especialmente quando são casos extremos. Ao construir soluções de IA, é necessário um foco substancial em como lidar com uma ampla variedade de circunstâncias que as soluções de IA podem encontrar. Por exemplo, um carro autônomo precisa priorizar a segurança das pessoas. Como resultado, a IA que alimenta o carro precisa considerar todos os cenários possíveis que o carro pode enfrentar, como noite, tempestades, nevascas, crianças correndo pela rua, animais de estimação, construções na estrada, etc. Quão bem um sistema de IA pode lidar com uma ampla gama de condições de forma confiável e segura reflete o nível de antecipação que o cientista de dados ou desenvolvedor de IA considerou durante o design ou teste do sistema.
+
+> [🎥 Clique aqui para assistir ao vídeo: ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
+
+### Inclusão
+
+Sistemas de IA devem ser projetados para engajar e capacitar todos. Ao projetar e implementar sistemas de IA, cientistas de dados e desenvolvedores de IA identificam e abordam possíveis barreiras no sistema que poderiam excluir pessoas de forma não intencional. Por exemplo, existem 1 bilhão de pessoas com deficiência em todo o mundo. Com o avanço da IA, elas podem acessar uma ampla gama de informações e oportunidades mais facilmente em suas vidas diárias. Ao abordar as barreiras, cria-se oportunidades para inovar e desenvolver produtos de IA com melhores experiências que beneficiem todos.
+
+> [🎥 Clique aqui para assistir ao vídeo: inclusão em IA](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
+
+### Segurança e privacidade
+
+Sistemas de IA devem ser seguros e respeitar a privacidade das pessoas. As pessoas têm menos confiança em sistemas que colocam sua privacidade, informações ou vidas em risco. Ao treinar modelos de aprendizado de máquina, dependemos de dados para produzir os melhores resultados. Ao fazer isso, a origem dos dados e sua integridade devem ser consideradas. Por exemplo, os dados foram enviados por usuários ou estão disponíveis publicamente? Além disso, ao trabalhar com os dados, é crucial desenvolver sistemas de IA que possam proteger informações confidenciais e resistir a ataques. À medida que a IA se torna mais prevalente, proteger a privacidade e garantir a segurança de informações pessoais e empresariais importantes está se tornando mais crítico e complexo. Questões de privacidade e segurança de dados exigem atenção especial para IA porque o acesso aos dados é essencial para que os sistemas de IA façam previsões e decisões precisas e informadas sobre as pessoas.
+
+> [🎥 Clique aqui para assistir ao vídeo: segurança em IA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
+
+- Como indústria, fizemos avanços significativos em privacidade e segurança, impulsionados significativamente por regulamentações como o GDPR (Regulamento Geral de Proteção de Dados).
+- No entanto, com sistemas de IA, devemos reconhecer a tensão entre a necessidade de mais dados pessoais para tornar os sistemas mais personalizados e eficazes – e a privacidade.
+- Assim como com o nascimento de computadores conectados à internet, também estamos vendo um grande aumento no número de problemas de segurança relacionados à IA.
+- Ao mesmo tempo, vimos a IA sendo usada para melhorar a segurança. Por exemplo, a maioria dos scanners antivírus modernos é alimentada por heurísticas de IA.
+- Precisamos garantir que nossos processos de ciência de dados se harmonizem com as práticas mais recentes de privacidade e segurança.
+
+### Transparência
+
+Sistemas de IA devem ser compreensíveis. Uma parte crucial da transparência é explicar o comportamento dos sistemas de IA e seus componentes. Melhorar a compreensão dos sistemas de IA exige que as partes interessadas compreendam como e por que eles funcionam, para que possam identificar possíveis problemas de desempenho, preocupações de segurança e privacidade, preconceitos, práticas excludentes ou resultados indesejados. Também acreditamos que aqueles que usam sistemas de IA devem ser honestos e transparentes sobre quando, por que e como escolhem implantá-los, bem como sobre as limitações dos sistemas que utilizam. Por exemplo, se um banco usa um sistema de IA para apoiar suas decisões de empréstimos ao consumidor, é importante examinar os resultados e entender quais dados influenciam as recomendações do sistema. Governos estão começando a regulamentar a IA em diferentes indústrias, então cientistas de dados e organizações devem explicar se um sistema de IA atende aos requisitos regulatórios, especialmente quando há um resultado indesejável.
+
+> [🎥 Clique aqui para assistir ao vídeo: transparência em IA](https://www.microsoft.com/videoplayer/embed/RE4voJF)
+
+- Como os sistemas de IA são tão complexos, é difícil entender como eles funcionam e interpretar os resultados.
+- Essa falta de compreensão afeta a forma como esses sistemas são gerenciados, operacionalizados e documentados.
+- Mais importante ainda, essa falta de compreensão afeta as decisões tomadas com base nos resultados que esses sistemas produzem.
+
+### Responsabilidade
+
+As pessoas que projetam e implantam sistemas de IA devem ser responsáveis pelo funcionamento de seus sistemas. A necessidade de responsabilidade é particularmente crucial com tecnologias sensíveis, como reconhecimento facial. Recentemente, houve uma demanda crescente por tecnologia de reconhecimento facial, especialmente de organizações de aplicação da lei que veem o potencial da tecnologia em usos como encontrar crianças desaparecidas. No entanto, essas tecnologias podem ser usadas por um governo para colocar em risco as liberdades fundamentais de seus cidadãos, por exemplo, permitindo vigilância contínua de indivíduos específicos. Portanto, cientistas de dados e organizações precisam ser responsáveis pelo impacto de seus sistemas de IA sobre indivíduos ou a sociedade.
+
+[![Pesquisador líder em IA alerta sobre vigilância em massa por meio de reconhecimento facial](../../../../1-Introduction/3-fairness/images/accountability.png)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Abordagem da Microsoft para IA Responsável")
+
+> 🎥 Clique na imagem acima para assistir ao vídeo: Alertas sobre vigilância em massa por meio de reconhecimento facial
+
+No final, uma das maiores questões para nossa geração, como a primeira geração que está trazendo IA para a sociedade, é como garantir que os computadores permaneçam responsáveis perante as pessoas e como garantir que as pessoas que projetam computadores permaneçam responsáveis perante todos os outros.
+
+## Avaliação de impacto
+
+Antes de treinar um modelo de aprendizado de máquina, é importante realizar uma avaliação de impacto para entender o propósito do sistema de IA; qual é o uso pretendido; onde ele será implantado; e quem interagirá com o sistema. Essas informações são úteis para os revisores ou testadores avaliarem o sistema e saberem quais fatores considerar ao identificar riscos potenciais e consequências esperadas.
+
+As seguintes áreas devem ser focadas ao realizar uma avaliação de impacto:
+
+* **Impacto adverso sobre indivíduos**. Estar ciente de quaisquer restrições ou requisitos, uso não suportado ou limitações conhecidas que possam prejudicar o desempenho do sistema é vital para garantir que o sistema não seja usado de forma a causar danos às pessoas.
+* **Requisitos de dados**. Compreender como e onde o sistema usará dados permite que os revisores explorem quaisquer requisitos de dados que você precise considerar (por exemplo, regulamentações de dados como GDPR ou HIPAA). Além disso, examine se a origem ou quantidade de dados é substancial para o treinamento.
+* **Resumo do impacto**. Reúna uma lista de possíveis danos que podem surgir do uso do sistema. Ao longo do ciclo de vida do aprendizado de máquina, revise se os problemas identificados foram mitigados ou resolvidos.
+* **Metas aplicáveis** para cada um dos seis princípios fundamentais. Avalie se as metas de cada princípio foram atendidas e se há lacunas.
+
+## Depuração com IA responsável
+
+Semelhante à depuração de uma aplicação de software, depurar um sistema de IA é um processo necessário para identificar e resolver problemas no sistema. Há muitos fatores que podem afetar o desempenho de um modelo ou sua responsabilidade. A maioria das métricas tradicionais de desempenho de modelos são agregados quantitativos do desempenho de um modelo, o que não é suficiente para analisar como um modelo viola os princípios de IA responsável. Além disso, um modelo de aprendizado de máquina é uma "caixa preta", o que dificulta entender o que impulsiona seus resultados ou fornecer explicações quando ele comete erros. Mais adiante neste curso, aprenderemos como usar o painel de IA Responsável para ajudar a depurar sistemas de IA. O painel fornece uma ferramenta holística para cientistas de dados e desenvolvedores de IA realizarem:
+
+* **Análise de erros**. Para identificar a distribuição de erros do modelo que pode afetar a equidade ou confiabilidade do sistema.
+* **Visão geral do modelo**. Para descobrir onde há disparidades no desempenho do modelo entre diferentes grupos de dados.
+* **Análise de dados**. Para entender a distribuição dos dados e identificar possíveis preconceitos nos dados que possam levar a problemas de equidade, inclusão e confiabilidade.
+* **Interpretabilidade do modelo**. Para entender o que afeta ou influencia as previsões do modelo. Isso ajuda a explicar o comportamento do modelo, o que é importante para transparência e responsabilidade.
+
+## 🚀 Desafio
+
+Para evitar que danos sejam introduzidos desde o início, devemos:
+
+- ter diversidade de origens e perspectivas entre as pessoas que trabalham nos sistemas
+- investir em conjuntos de dados que reflitam a diversidade de nossa sociedade
+- desenvolver melhores métodos ao longo do ciclo de vida do aprendizado de máquina para detectar e corrigir problemas de IA responsável quando eles ocorrerem
+
+Pense em cenários da vida real onde a falta de confiabilidade de um modelo é evidente na construção e uso do modelo. O que mais devemos considerar?
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+## Revisão e Autoestudo
+
+Nesta lição, você aprendeu alguns conceitos básicos sobre equidade e injustiça no aprendizado de máquina.
+Assista a este workshop para se aprofundar nos tópicos:
+
+- Em busca de IA responsável: Colocando princípios em prática por Besmira Nushi, Mehrnoosh Sameki e Amit Sharma
+
+[![Responsible AI Toolbox: Um framework de código aberto para construir IA responsável](https://img.youtube.com/vi/tGgJCrA-MZU/0.jpg)](https://www.youtube.com/watch?v=tGgJCrA-MZU "RAI Toolbox: Um framework de código aberto para construir IA responsável")
+
+> 🎥 Clique na imagem acima para assistir ao vídeo: RAI Toolbox: Um framework de código aberto para construir IA responsável por Besmira Nushi, Mehrnoosh Sameki e Amit Sharma
+
+Além disso, leia:
+
+- Centro de recursos de IA responsável da Microsoft: [Responsible AI Resources – Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
+
+- Grupo de pesquisa FATE da Microsoft: [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
+
+RAI Toolbox:
+
+- [Repositório GitHub do Responsible AI Toolbox](https://github.com/microsoft/responsible-ai-toolbox)
+
+Leia sobre as ferramentas do Azure Machine Learning para garantir equidade:
+
+- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott)
+
+## Tarefa
+
+[Explore o RAI Toolbox](assignment.md)
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/1-Introduction/3-fairness/assignment.md

@@ -0,0 +1,16 @@
+# Explore o Toolbox de IA Responsável
+
+## Instruções
+
+Nesta lição, você aprendeu sobre o Toolbox de IA Responsável, um "projeto de código aberto e orientado pela comunidade para ajudar cientistas de dados a analisar e melhorar sistemas de IA." Para esta tarefa, explore um dos [notebooks](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) do Toolbox de IA Responsável e relate suas descobertas em um artigo ou apresentação.
+
+## Rubrica
+
+| Critérios | Exemplar | Adequado | Necessita Melhorias |
+| --------- | -------- | -------- | ------------------- |
+|           | Um artigo ou apresentação em PowerPoint é apresentado discutindo os sistemas do Fairlearn, o notebook que foi executado e as conclusões obtidas a partir da execução | Um artigo é apresentado sem conclusões | Nenhum artigo é apresentado |
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/1-Introduction/4-techniques-of-ML/README.md

@@ -0,0 +1,123 @@
+# Técnicas de Aprendizado de Máquina
+
+O processo de construir, usar e manter modelos de aprendizado de máquina e os dados que eles utilizam é muito diferente de muitos outros fluxos de trabalho de desenvolvimento. Nesta lição, vamos desmistificar o processo e delinear as principais técnicas que você precisa conhecer. Você irá:
+
+- Compreender os processos que sustentam o aprendizado de máquina em um nível geral.
+- Explorar conceitos básicos como 'modelos', 'previsões' e 'dados de treinamento'.
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+[![ML para iniciantes - Técnicas de Aprendizado de Máquina](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "ML para iniciantes - Técnicas de Aprendizado de Máquina")
+
+> 🎥 Clique na imagem acima para assistir a um vídeo curto sobre esta lição.
+
+## Introdução
+
+Em um nível geral, a prática de criar processos de aprendizado de máquina (ML) é composta por várias etapas:
+
+1. **Definir a pergunta**. A maioria dos processos de ML começa com uma pergunta que não pode ser respondida por um programa condicional simples ou um mecanismo baseado em regras. Essas perguntas geralmente giram em torno de previsões baseadas em um conjunto de dados.
+2. **Coletar e preparar os dados**. Para responder à sua pergunta, você precisa de dados. A qualidade e, às vezes, a quantidade dos seus dados determinarão o quão bem você pode responder à pergunta inicial. Visualizar os dados é um aspecto importante desta fase. Esta etapa também inclui dividir os dados em grupos de treinamento e teste para construir um modelo.
+3. **Escolher um método de treinamento**. Dependendo da sua pergunta e da natureza dos seus dados, você precisa escolher como deseja treinar um modelo para refletir melhor seus dados e fazer previsões precisas. Esta é a parte do processo de ML que exige expertise específica e, frequentemente, uma quantidade considerável de experimentação.
+4. **Treinar o modelo**. Usando seus dados de treinamento, você aplicará vários algoritmos para treinar um modelo que reconheça padrões nos dados. O modelo pode usar pesos internos que podem ser ajustados para privilegiar certas partes dos dados em detrimento de outras, a fim de construir um modelo melhor.
+5. **Avaliar o modelo**. Você usa dados nunca antes vistos (seus dados de teste) do conjunto coletado para verificar o desempenho do modelo.
+6. **Ajustar parâmetros**. Com base no desempenho do modelo, você pode refazer o processo usando diferentes parâmetros ou variáveis que controlam o comportamento dos algoritmos usados para treinar o modelo.
+7. **Prever**. Use novas entradas para testar a precisão do modelo.
+
+## Qual pergunta fazer
+
+Os computadores são particularmente habilidosos em descobrir padrões ocultos nos dados. Essa utilidade é muito útil para pesquisadores que têm perguntas sobre um determinado domínio que não podem ser facilmente respondidas criando um mecanismo baseado em regras condicionais. Dado um trabalho atuarial, por exemplo, um cientista de dados pode construir regras personalizadas sobre a mortalidade de fumantes versus não fumantes.
+
+Quando muitas outras variáveis são incluídas na equação, no entanto, um modelo de ML pode ser mais eficiente para prever taxas de mortalidade futuras com base no histórico de saúde anterior. Um exemplo mais animador pode ser fazer previsões meteorológicas para o mês de abril em um determinado local com base em dados que incluem latitude, longitude, mudanças climáticas, proximidade ao oceano, padrões de correntes de jato e mais.
+
+✅ Este [slide deck](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) sobre modelos meteorológicos oferece uma perspectiva histórica sobre o uso de ML na análise climática.  
+
+## Tarefas pré-construção
+
+Antes de começar a construir seu modelo, há várias tarefas que você precisa completar. Para testar sua pergunta e formar uma hipótese com base nas previsões de um modelo, você precisa identificar e configurar vários elementos.
+
+### Dados
+
+Para responder à sua pergunta com algum grau de certeza, você precisa de uma boa quantidade de dados do tipo certo. Há duas coisas que você precisa fazer neste momento:
+
+- **Coletar dados**. Lembre-se da lição anterior sobre justiça na análise de dados e colete seus dados com cuidado. Esteja atento às fontes desses dados, quaisquer vieses inerentes que possam ter e documente sua origem.
+- **Preparar dados**. Há várias etapas no processo de preparação de dados. Você pode precisar reunir dados e normalizá-los se vierem de fontes diversas. Você pode melhorar a qualidade e a quantidade dos dados por meio de vários métodos, como converter strings em números (como fazemos em [Clustering](../../5-Clustering/1-Visualize/README.md)). Você também pode gerar novos dados com base nos originais (como fazemos em [Classificação](../../4-Classification/1-Introduction/README.md)). Você pode limpar e editar os dados (como faremos antes da lição de [Aplicativo Web](../../3-Web-App/README.md)). Por fim, pode ser necessário randomizar e embaralhar os dados, dependendo das técnicas de treinamento.
+
+✅ Após coletar e processar seus dados, reserve um momento para verificar se sua estrutura permitirá que você responda à pergunta pretendida. Pode ser que os dados não funcionem bem na tarefa proposta, como descobrimos em nossas lições de [Clustering](../../5-Clustering/1-Visualize/README.md)!
+
+### Features e Target
+
+Uma [feature](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) é uma propriedade mensurável dos seus dados. Em muitos conjuntos de dados, ela é expressa como um cabeçalho de coluna, como 'data', 'tamanho' ou 'cor'. Sua variável de feature, geralmente representada como `X` no código, representa a variável de entrada que será usada para treinar o modelo.
+
+Um target é aquilo que você está tentando prever. O target, geralmente representado como `y` no código, representa a resposta à pergunta que você está tentando fazer com seus dados: em dezembro, qual **cor** de abóbora será mais barata? Em São Francisco, quais bairros terão o melhor **preço** de imóveis? Às vezes, o target também é chamado de atributo de rótulo.
+
+### Selecionando sua variável de feature
+
+🎓 **Seleção de Features e Extração de Features** Como saber qual variável escolher ao construir um modelo? Você provavelmente passará por um processo de seleção ou extração de features para escolher as variáveis certas para o modelo mais eficiente. No entanto, elas não são a mesma coisa: "A extração de features cria novas features a partir de funções das features originais, enquanto a seleção de features retorna um subconjunto das features." ([fonte](https://wikipedia.org/wiki/Feature_selection))
+
+### Visualizar seus dados
+
+Um aspecto importante do kit de ferramentas do cientista de dados é o poder de visualizar dados usando várias bibliotecas excelentes, como Seaborn ou MatPlotLib. Representar seus dados visualmente pode permitir que você descubra correlações ocultas que pode aproveitar. Suas visualizações também podem ajudar a identificar vieses ou dados desbalanceados (como descobrimos em [Classificação](../../4-Classification/2-Classifiers-1/README.md)).
+
+### Dividir seu conjunto de dados
+
+Antes de treinar, você precisa dividir seu conjunto de dados em duas ou mais partes de tamanhos desiguais que ainda representem bem os dados.
+
+- **Treinamento**. Esta parte do conjunto de dados é ajustada ao seu modelo para treiná-lo. Este conjunto constitui a maior parte do conjunto de dados original.
+- **Teste**. Um conjunto de teste é um grupo independente de dados, frequentemente extraído dos dados originais, que você usa para confirmar o desempenho do modelo construído.
+- **Validação**. Um conjunto de validação é um grupo menor e independente de exemplos que você usa para ajustar os hiperparâmetros ou a arquitetura do modelo para melhorá-lo. Dependendo do tamanho dos seus dados e da pergunta que você está fazendo, pode não ser necessário construir este terceiro conjunto (como observamos em [Previsão de Séries Temporais](../../7-TimeSeries/1-Introduction/README.md)).
+
+## Construindo um modelo
+
+Usando seus dados de treinamento, seu objetivo é construir um modelo, ou uma representação estatística dos seus dados, usando vários algoritmos para **treiná-lo**. Treinar um modelo o expõe aos dados e permite que ele faça suposições sobre padrões percebidos que descobre, valida e aceita ou rejeita.
+
+### Decidir sobre um método de treinamento
+
+Dependendo da sua pergunta e da natureza dos seus dados, você escolherá um método para treiná-lo. Explorando a [documentação do Scikit-learn](https://scikit-learn.org/stable/user_guide.html) - que usamos neste curso - você pode explorar várias maneiras de treinar um modelo. Dependendo da sua experiência, pode ser necessário tentar vários métodos diferentes para construir o melhor modelo. É provável que você passe por um processo em que cientistas de dados avaliam o desempenho de um modelo alimentando-o com dados não vistos, verificando sua precisão, vieses e outros problemas que degradam a qualidade, e selecionando o método de treinamento mais apropriado para a tarefa.
+
+### Treinar um modelo
+
+Com seus dados de treinamento em mãos, você está pronto para 'ajustá-los' e criar um modelo. Você notará que em muitas bibliotecas de ML encontrará o código 'model.fit' - é neste momento que você envia sua variável de feature como um array de valores (geralmente 'X') e uma variável de target (geralmente 'y').
+
+### Avaliar o modelo
+
+Uma vez concluído o processo de treinamento (pode levar muitas iterações, ou 'épocas', para treinar um modelo grande), você poderá avaliar a qualidade do modelo usando dados de teste para medir seu desempenho. Esses dados são um subconjunto dos dados originais que o modelo ainda não analisou. Você pode imprimir uma tabela de métricas sobre a qualidade do modelo.
+
+🎓 **Ajuste do modelo**
+
+No contexto de aprendizado de máquina, ajuste do modelo refere-se à precisão da função subjacente do modelo ao tentar analisar dados com os quais não está familiarizado.
+
+🎓 **Subajuste** e **superajuste** são problemas comuns que degradam a qualidade do modelo, pois ele se ajusta de forma insuficiente ou excessiva. Isso faz com que o modelo faça previsões muito alinhadas ou pouco alinhadas com seus dados de treinamento. Um modelo superajustado prevê os dados de treinamento muito bem porque aprendeu os detalhes e ruídos dos dados excessivamente. Um modelo subajustado não é preciso, pois não consegue analisar com precisão nem seus dados de treinamento nem os dados que ainda não 'viu'.
+
+![modelo superajustado](../../../../1-Introduction/4-techniques-of-ML/images/overfitting.png)
+> Infográfico por [Jen Looper](https://twitter.com/jenlooper)
+
+## Ajuste de parâmetros
+
+Depois de concluir o treinamento inicial, observe a qualidade do modelo e considere melhorá-lo ajustando seus 'hiperparâmetros'. Leia mais sobre o processo [na documentação](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
+
+## Previsão
+
+Este é o momento em que você pode usar dados completamente novos para testar a precisão do modelo. Em um cenário de ML 'aplicado', onde você está construindo ativos web para usar o modelo em produção, este processo pode envolver coletar entrada do usuário (um clique de botão, por exemplo) para definir uma variável e enviá-la ao modelo para inferência ou avaliação.
+
+Nestes módulos, você descobrirá como usar essas etapas para preparar, construir, testar, avaliar e prever - todos os gestos de um cientista de dados e mais, enquanto avança em sua jornada para se tornar um engenheiro de ML 'full stack'.
+
+---
+
+## 🚀Desafio
+
+Desenhe um fluxograma refletindo as etapas de um profissional de ML. Onde você se vê agora no processo? Onde você prevê que encontrará dificuldades? O que parece fácil para você?
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+## Revisão e Autoestudo
+
+Pesquise online entrevistas com cientistas de dados que discutem seu trabalho diário. Aqui está [uma](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
+
+## Tarefa
+
+[Entrevistar um cientista de dados](assignment.md)
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/1-Introduction/4-techniques-of-ML/assignment.md

@@ -0,0 +1,16 @@
+# Entrevista com um cientista de dados
+
+## Instruções
+
+Na sua empresa, em um grupo de usuários, ou entre seus amigos ou colegas de estudo, converse com alguém que trabalha profissionalmente como cientista de dados. Escreva um pequeno artigo (500 palavras) sobre as ocupações diárias dessa pessoa. Eles são especialistas ou trabalham de forma 'full stack'?
+
+## Rubrica
+
+| Critérios | Exemplar                                                                            | Adequado                                                           | Precisa Melhorar      |
+| --------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------ | --------------------- |
+|           | Um artigo com o comprimento correto, com fontes atribuídas, apresentado como um arquivo .doc | O artigo tem atribuições inadequadas ou é mais curto que o comprimento exigido | Nenhum artigo é apresentado |
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/1-Introduction/README.md

@@ -0,0 +1,28 @@
+# Introdução ao aprendizado de máquina
+
+Nesta seção do currículo, você será apresentado aos conceitos básicos que fundamentam o campo do aprendizado de máquina, o que ele é, e aprenderá sobre sua história e as técnicas que os pesquisadores utilizam para trabalhar com ele. Vamos explorar juntos este novo mundo do aprendizado de máquina!
+
+![globo](../../../translated_images/pt-BR/globe.59f26379ceb40428.webp)  
+> Foto por <a href="https://unsplash.com/@bill_oxford?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Bill Oxford</a> no <a href="https://unsplash.com/s/photos/globe?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
+
+### Aulas
+
+1. [Introdução ao aprendizado de máquina](1-intro-to-ML/README.md)  
+1. [A história do aprendizado de máquina e da IA](2-history-of-ML/README.md)  
+1. [Equidade e aprendizado de máquina](3-fairness/README.md)  
+1. [Técnicas de aprendizado de máquina](4-techniques-of-ML/README.md)  
+
+### Créditos
+
+"Introdução ao Aprendizado de Máquina" foi escrito com ♥️ por uma equipe de pessoas incluindo [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan), [Ornella Altunyan](https://twitter.com/ornelladotcom) e [Jen Looper](https://twitter.com/jenlooper)  
+
+"A História do Aprendizado de Máquina" foi escrito com ♥️ por [Jen Looper](https://twitter.com/jenlooper) e [Amy Boyd](https://twitter.com/AmyKateNicho)  
+
+"Equidade e Aprendizado de Máquina" foi escrito com ♥️ por [Tomomi Imura](https://twitter.com/girliemac)  
+
+"Técnicas de Aprendizado de Máquina" foi escrito com ♥️ por [Jen Looper](https://twitter.com/jenlooper) e [Chris Noring](https://twitter.com/softchris)  
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/1-Tools/README.md

@@ -0,0 +1,230 @@
+# Introdução ao Python e Scikit-learn para modelos de regressão
+
+![Resumo de regressões em um sketchnote](../../../../sketchnotes/ml-regression.png)
+
+> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+> ### [Esta lição está disponível em R!](../../../../2-Regression/1-Tools/solution/R/lesson_1.html)
+
+## Introdução
+
+Nestas quatro lições, você descobrirá como construir modelos de regressão. Vamos discutir para que eles servem em breve. Mas antes de começar, certifique-se de ter as ferramentas certas para iniciar o processo!
+
+Nesta lição, você aprenderá a:
+
+- Configurar seu computador para tarefas locais de aprendizado de máquina.
+- Trabalhar com notebooks Jupyter.
+- Utilizar Scikit-learn, incluindo sua instalação.
+- Explorar regressão linear com um exercício prático.
+
+## Instalações e configurações
+
+[![ML para iniciantes - Configure suas ferramentas para criar modelos de aprendizado de máquina](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML para iniciantes - Configure suas ferramentas para criar modelos de aprendizado de máquina")
+
+> 🎥 Clique na imagem acima para um vídeo curto sobre como configurar seu computador para ML.
+
+1. **Instale o Python**. Certifique-se de que o [Python](https://www.python.org/downloads/) está instalado em seu computador. Você usará Python para muitas tarefas de ciência de dados e aprendizado de máquina. A maioria dos sistemas de computador já inclui uma instalação do Python. Há também [Pacotes de Codificação Python](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) úteis disponíveis para facilitar a configuração para alguns usuários.
+
+   Algumas utilizações do Python, no entanto, exigem uma versão específica do software, enquanto outras requerem uma versão diferente. Por essa razão, é útil trabalhar dentro de um [ambiente virtual](https://docs.python.org/3/library/venv.html).
+
+2. **Instale o Visual Studio Code**. Certifique-se de que o Visual Studio Code está instalado em seu computador. Siga estas instruções para [instalar o Visual Studio Code](https://code.visualstudio.com/) para a instalação básica. Você usará Python no Visual Studio Code neste curso, então pode ser útil revisar como [configurar o Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) para desenvolvimento em Python.
+
+   > Familiarize-se com Python trabalhando nesta coleção de [módulos de aprendizado](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)
+   >
+   > [![Configurar Python com Visual Studio Code](https://img.youtube.com/vi/yyQM70vi7V8/0.jpg)](https://youtu.be/yyQM70vi7V8 "Configurar Python com Visual Studio Code")
+   >
+   > 🎥 Clique na imagem acima para um vídeo: usando Python no VS Code.
+
+3. **Instale o Scikit-learn**, seguindo [estas instruções](https://scikit-learn.org/stable/install.html). Como você precisa garantir que está usando Python 3, é recomendado que utilize um ambiente virtual. Note que, se estiver instalando esta biblioteca em um Mac M1, há instruções especiais na página vinculada acima.
+
+4. **Instale o Jupyter Notebook**. Você precisará [instalar o pacote Jupyter](https://pypi.org/project/jupyter/).
+
+## Seu ambiente de autoria de ML
+
+Você usará **notebooks** para desenvolver seu código Python e criar modelos de aprendizado de máquina. Este tipo de arquivo é uma ferramenta comum para cientistas de dados e pode ser identificado por seu sufixo ou extensão `.ipynb`.
+
+Notebooks são um ambiente interativo que permite ao desenvolvedor tanto codificar quanto adicionar notas e escrever documentação em torno do código, o que é bastante útil para projetos experimentais ou orientados à pesquisa.
+
+[![ML para iniciantes - Configure Jupyter Notebooks para começar a construir modelos de regressão](https://img.youtube.com/vi/7E-jC8FLA2E/0.jpg)](https://youtu.be/7E-jC8FLA2E "ML para iniciantes - Configure Jupyter Notebooks para começar a construir modelos de regressão")
+
+> 🎥 Clique na imagem acima para um vídeo curto sobre este exercício.
+
+### Exercício - Trabalhando com um notebook
+
+Nesta pasta, você encontrará o arquivo _notebook.ipynb_.
+
+1. Abra _notebook.ipynb_ no Visual Studio Code.
+
+   Um servidor Jupyter será iniciado com Python 3+. Você encontrará áreas do notebook que podem ser `executadas`, pedaços de código. Você pode executar um bloco de código selecionando o ícone que parece um botão de reprodução.
+
+2. Selecione o ícone `md` e adicione um pouco de markdown, com o seguinte texto **# Bem-vindo ao seu notebook**.
+
+   Em seguida, adicione algum código Python.
+
+3. Digite **print('hello notebook')** no bloco de código.
+4. Selecione a seta para executar o código.
+
+   Você deverá ver a declaração impressa:
+
+    ```output
+    hello notebook
+    ```
+
+![VS Code com um notebook aberto](../../../../2-Regression/1-Tools/images/notebook.jpg)
+
+Você pode intercalar seu código com comentários para auto-documentar o notebook.
+
+✅ Pense por um momento como o ambiente de trabalho de um desenvolvedor web é diferente do de um cientista de dados.
+
+## Começando com Scikit-learn
+
+Agora que o Python está configurado em seu ambiente local e você está confortável com notebooks Jupyter, vamos nos familiarizar com o Scikit-learn (pronuncia-se `sci` como em `science`). O Scikit-learn fornece uma [API extensa](https://scikit-learn.org/stable/modules/classes.html#api-ref) para ajudá-lo a realizar tarefas de ML.
+
+De acordo com seu [site](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn é uma biblioteca de aprendizado de máquina de código aberto que suporta aprendizado supervisionado e não supervisionado. Também fornece várias ferramentas para ajuste de modelos, pré-processamento de dados, seleção e avaliação de modelos, e muitas outras utilidades."
+
+Neste curso, você usará Scikit-learn e outras ferramentas para construir modelos de aprendizado de máquina para realizar o que chamamos de tarefas de 'aprendizado de máquina tradicional'. Evitamos deliberadamente redes neurais e aprendizado profundo, pois eles são melhor abordados em nosso futuro currículo 'AI para Iniciantes'.
+
+O Scikit-learn torna simples construir modelos e avaliá-los para uso. Ele é focado principalmente em usar dados numéricos e contém vários conjuntos de dados prontos para uso como ferramentas de aprendizado. Também inclui modelos pré-construídos para os alunos experimentarem. Vamos explorar o processo de carregar dados pré-empacotados e usar um estimador para criar o primeiro modelo de ML com Scikit-learn usando alguns dados básicos.
+
+## Exercício - Seu primeiro notebook com Scikit-learn
+
+> Este tutorial foi inspirado pelo [exemplo de regressão linear](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) no site do Scikit-learn.
+
+[![ML para iniciantes - Seu primeiro projeto de regressão linear em Python](https://img.youtube.com/vi/2xkXL5EUpS0/0.jpg)](https://youtu.be/2xkXL5EUpS0 "ML para iniciantes - Seu primeiro projeto de regressão linear em Python")
+
+> 🎥 Clique na imagem acima para um vídeo curto sobre este exercício.
+
+No arquivo _notebook.ipynb_ associado a esta lição, limpe todas as células pressionando o ícone de 'lixeira'.
+
+Nesta seção, você trabalhará com um pequeno conjunto de dados sobre diabetes que está embutido no Scikit-learn para fins de aprendizado. Imagine que você deseja testar um tratamento para pacientes diabéticos. Modelos de aprendizado de máquina podem ajudá-lo a determinar quais pacientes responderiam melhor ao tratamento, com base em combinações de variáveis. Mesmo um modelo de regressão muito básico, quando visualizado, pode mostrar informações sobre variáveis que ajudariam a organizar seus ensaios clínicos teóricos.
+
+✅ Existem muitos tipos de métodos de regressão, e qual você escolhe depende da resposta que está procurando. Se você quiser prever a altura provável de uma pessoa de uma determinada idade, usaria regressão linear, pois está buscando um **valor numérico**. Se estiver interessado em descobrir se um tipo de culinária deve ser considerado vegano ou não, estará buscando uma **atribuição de categoria**, então usaria regressão logística. Você aprenderá mais sobre regressão logística mais tarde. Pense um pouco sobre algumas perguntas que você pode fazer aos dados e qual desses métodos seria mais apropriado.
+
+Vamos começar esta tarefa.
+
+### Importar bibliotecas
+
+Para esta tarefa, importaremos algumas bibliotecas:
+
+- **matplotlib**. É uma ferramenta útil para [criação de gráficos](https://matplotlib.org/) e a usaremos para criar um gráfico de linha.
+- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) é uma biblioteca útil para lidar com dados numéricos em Python.
+- **sklearn**. Esta é a biblioteca [Scikit-learn](https://scikit-learn.org/stable/user_guide.html).
+
+Importe algumas bibliotecas para ajudar em suas tarefas.
+
+1. Adicione as importações digitando o seguinte código:
+
+   ```python
+   import matplotlib.pyplot as plt
+   import numpy as np
+   from sklearn import datasets, linear_model, model_selection
+   ```
+
+   Acima, você está importando `matplotlib`, `numpy` e está importando `datasets`, `linear_model` e `model_selection` de `sklearn`. `model_selection` é usado para dividir dados em conjuntos de treinamento e teste.
+
+### O conjunto de dados de diabetes
+
+O [conjunto de dados de diabetes](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) embutido inclui 442 amostras de dados sobre diabetes, com 10 variáveis de características, algumas das quais incluem:
+
+- age: idade em anos
+- bmi: índice de massa corporal
+- bp: pressão arterial média
+- s1 tc: células T (um tipo de glóbulo branco)
+
+✅ Este conjunto de dados inclui o conceito de 'sexo' como uma variável de característica importante para pesquisas sobre diabetes. Muitos conjuntos de dados médicos incluem este tipo de classificação binária. Pense um pouco sobre como categorizações como esta podem excluir certas partes da população de tratamentos.
+
+Agora, carregue os dados X e y.
+
+> 🎓 Lembre-se, este é aprendizado supervisionado, e precisamos de um 'y' alvo nomeado.
+
+Em uma nova célula de código, carregue o conjunto de dados de diabetes chamando `load_diabetes()`. O parâmetro `return_X_y=True` indica que `X` será uma matriz de dados e `y` será o alvo da regressão.
+
+1. Adicione alguns comandos de impressão para mostrar a forma da matriz de dados e seu primeiro elemento:
+
+    ```python
+    X, y = datasets.load_diabetes(return_X_y=True)
+    print(X.shape)
+    print(X[0])
+    ```
+
+    O que você está recebendo como resposta é uma tupla. O que você está fazendo é atribuir os dois primeiros valores da tupla a `X` e `y`, respectivamente. Saiba mais [sobre tuplas](https://wikipedia.org/wiki/Tuple).
+
+    Você pode ver que esses dados têm 442 itens organizados em arrays de 10 elementos:
+
+    ```text
+    (442, 10)
+    [ 0.03807591  0.05068012  0.06169621  0.02187235 -0.0442235  -0.03482076
+    -0.04340085 -0.00259226  0.01990842 -0.01764613]
+    ```
+
+    ✅ Pense um pouco sobre a relação entre os dados e o alvo da regressão. A regressão linear prevê relações entre a característica X e a variável alvo y. Você consegue encontrar o [alvo](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) para o conjunto de dados de diabetes na documentação? O que este conjunto de dados está demonstrando, dado o alvo?
+
+2. Em seguida, selecione uma parte deste conjunto de dados para plotar, escolhendo a 3ª coluna do conjunto de dados. Você pode fazer isso usando o operador `:` para selecionar todas as linhas e, em seguida, selecionando a 3ª coluna usando o índice (2). Você também pode remodelar os dados para serem um array 2D - conforme necessário para plotagem - usando `reshape(n_rows, n_columns)`. Se um dos parâmetros for -1, a dimensão correspondente será calculada automaticamente.
+
+   ```python
+   X = X[:, 2]
+   X = X.reshape((-1,1))
+   ```
+
+   ✅ A qualquer momento, imprima os dados para verificar sua forma.
+
+3. Agora que você tem os dados prontos para serem plotados, pode verificar se uma máquina pode ajudar a determinar uma divisão lógica entre os números neste conjunto de dados. Para fazer isso, você precisa dividir tanto os dados (X) quanto o alvo (y) em conjuntos de teste e treinamento. O Scikit-learn tem uma maneira simples de fazer isso; você pode dividir seus dados de teste em um ponto específico.
+
+   ```python
+   X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
+   ```
+
+4. Agora você está pronto para treinar seu modelo! Carregue o modelo de regressão linear e treine-o com seus conjuntos de treinamento X e y usando `model.fit()`:
+
+    ```python
+    model = linear_model.LinearRegression()
+    model.fit(X_train, y_train)
+    ```
+
+    ✅ `model.fit()` é uma função que você verá em muitas bibliotecas de ML, como TensorFlow.
+
+5. Em seguida, crie uma previsão usando os dados de teste, utilizando a função `predict()`. Isso será usado para desenhar a linha entre os grupos de dados.
+
+    ```python
+    y_pred = model.predict(X_test)
+    ```
+
+6. Agora é hora de mostrar os dados em um gráfico. O Matplotlib é uma ferramenta muito útil para esta tarefa. Crie um gráfico de dispersão de todos os dados de teste X e y e use a previsão para desenhar uma linha no lugar mais apropriado, entre os agrupamentos de dados do modelo.
+
+    ```python
+    plt.scatter(X_test, y_test,  color='black')
+    plt.plot(X_test, y_pred, color='blue', linewidth=3)
+    plt.xlabel('Scaled BMIs')
+    plt.ylabel('Disease Progression')
+    plt.title('A Graph Plot Showing Diabetes Progression Against BMI')
+    plt.show()
+    ```
+
+   ![um gráfico de dispersão mostrando pontos de dados sobre diabetes](../../../../2-Regression/1-Tools/images/scatterplot.png)
+✅ Pense um pouco sobre o que está acontecendo aqui. Uma linha reta está passando por muitos pequenos pontos de dados, mas o que exatamente ela está fazendo? Você consegue perceber como essa linha pode ser usada para prever onde um novo ponto de dados, ainda não visto, deve se encaixar em relação ao eixo y do gráfico? Tente colocar em palavras a utilidade prática desse modelo.
+
+Parabéns, você construiu seu primeiro modelo de regressão linear, criou uma previsão com ele e a exibiu em um gráfico!
+
+---
+## 🚀Desafio
+
+Plote uma variável diferente deste conjunto de dados. Dica: edite esta linha: `X = X[:,2]`. Dado o alvo deste conjunto de dados, o que você consegue descobrir sobre a progressão do diabetes como uma doença?
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+## Revisão e Autoestudo
+
+Neste tutorial, você trabalhou com regressão linear simples, em vez de regressão univariada ou múltipla. Leia um pouco sobre as diferenças entre esses métodos ou assista a [este vídeo](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef).
+
+Leia mais sobre o conceito de regressão e pense sobre quais tipos de perguntas podem ser respondidas por essa técnica. Faça este [tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) para aprofundar seu entendimento.
+
+## Tarefa
+
+[Um conjunto de dados diferente](assignment.md)
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/1-Tools/assignment.md

@@ -0,0 +1,18 @@
+# Regressão com Scikit-learn
+
+## Instruções
+
+Dê uma olhada no [conjunto de dados Linnerud](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_linnerud.html#sklearn.datasets.load_linnerud) no Scikit-learn. Este conjunto de dados possui múltiplos [alvos](https://scikit-learn.org/stable/datasets/toy_dataset.html#linnerrud-dataset): 'Ele consiste em três variáveis de exercício (dados) e três variáveis fisiológicas (alvo) coletadas de vinte homens de meia-idade em um clube de fitness'.
+
+Com suas próprias palavras, descreva como criar um modelo de Regressão que plote a relação entre a circunferência da cintura e a quantidade de abdominais realizados. Faça o mesmo para os outros pontos de dados deste conjunto de dados.
+
+## Rubrica
+
+| Critério                       | Exemplary                           | Adequado                      | Precisa de Melhorias       |
+| ------------------------------ | ----------------------------------- | ----------------------------- | -------------------------- |
+| Enviar um parágrafo descritivo | Um parágrafo bem escrito é enviado  | Algumas frases são enviadas   | Nenhuma descrição é fornecida |
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/1-Tools/solution/Julia/README.md

@@ -0,0 +1,6 @@
+
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/1-Tools/solution/R/lesson_1-R.ipynb

@@ -0,0 +1,447 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 2,
+ "metadata": {
+  "colab": {
+   "name": "lesson_1-R.ipynb",
+   "provenance": [],
+   "collapsed_sections": [],
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "name": "ir",
+   "display_name": "R"
+  },
+  "language_info": {
+   "name": "R"
+  },
+  "coopTranslator": {
+   "original_hash": "c18d3bd0bd8ae3878597e89dcd1fa5c1",
+   "translation_date": "2025-08-29T23:09:43+00:00",
+   "source_file": "2-Regression/1-Tools/solution/R/lesson_1-R.ipynb",
+   "language_code": "br"
+  }
+ },
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "source": [],
+   "metadata": {
+    "id": "YJUHCXqK57yz"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Introdução à Regressão - Aula 1\n",
+    "\n",
+    "#### Colocando em perspectiva\n",
+    "\n",
+    "✅ Existem muitos tipos de métodos de regressão, e qual você escolhe depende da resposta que está buscando. Se você quiser prever a altura provável de uma pessoa com uma determinada idade, usaria `regressão linear`, pois está procurando um **valor numérico**. Se estiver interessado em descobrir se um tipo de culinária deve ser considerado vegano ou não, estará buscando uma **atribuição de categoria**, então usaria `regressão logística`. Você aprenderá mais sobre regressão logística mais adiante. Pense um pouco sobre algumas perguntas que você pode fazer aos dados e quais desses métodos seriam mais apropriados.\n",
+    "\n",
+    "Nesta seção, você trabalhará com um [pequeno conjunto de dados sobre diabetes](https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html). Imagine que você queira testar um tratamento para pacientes diabéticos. Modelos de aprendizado de máquina podem ajudar a determinar quais pacientes responderiam melhor ao tratamento, com base em combinações de variáveis. Mesmo um modelo de regressão muito básico, quando visualizado, pode mostrar informações sobre variáveis que ajudariam você a organizar seus ensaios clínicos teóricos.\n",
+    "\n",
+    "Dito isso, vamos começar esta tarefa!\n",
+    "\n",
+    "<p >\n",
+    "   <img src=\"../../images/encouRage.jpg\"\n",
+    "   width=\"630\"/>\n",
+    "   <figcaption>Arte por @allison_horst</figcaption>\n",
+    "\n",
+    "<!--![Arte por \\@allison_horst](../../../../../../translated_images/pt-BR/encouRage.e75d5fe0367fb913.webp)<br>Arte por @allison_horst-->\n"
+   ],
+   "metadata": {
+    "id": "LWNNzfqd6feZ"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 1. Carregando nosso conjunto de ferramentas\n",
+    "\n",
+    "Para esta tarefa, vamos precisar dos seguintes pacotes:\n",
+    "\n",
+    "-   `tidyverse`: O [tidyverse](https://www.tidyverse.org/) é uma [coleção de pacotes R](https://www.tidyverse.org/packages) projetada para tornar a ciência de dados mais rápida, fácil e divertida!\n",
+    "\n",
+    "-   `tidymodels`: O [tidymodels](https://www.tidymodels.org/) é uma [coleção de pacotes](https://www.tidymodels.org/packages/) para modelagem e aprendizado de máquina.\n",
+    "\n",
+    "Você pode instalá-los com o seguinte comando:\n",
+    "\n",
+    "`install.packages(c(\"tidyverse\", \"tidymodels\"))`\n",
+    "\n",
+    "O script abaixo verifica se você possui os pacotes necessários para completar este módulo e os instala para você caso algum esteja faltando.\n"
+   ],
+   "metadata": {
+    "id": "FIo2YhO26wI9"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "source": [
+    "suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\n",
+    "pacman::p_load(tidyverse, tidymodels)"
+   ],
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "Loading required package: pacman\n",
+      "\n"
+     ]
+    }
+   ],
+   "metadata": {
+    "id": "cIA9fz9v7Dss",
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "outputId": "2df7073b-86b2-4b32-cb86-0da605a0dc11"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Agora, vamos carregar esses pacotes incríveis e torná-los disponíveis na nossa sessão atual do R. (Isso é apenas para ilustração, `pacman::p_load()` já fez isso por você)\n"
+   ],
+   "metadata": {
+    "id": "gpO_P_6f9WUG"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# load the core Tidyverse packages\r\n",
+    "library(tidyverse)\r\n",
+    "\r\n",
+    "# load the core Tidymodels packages\r\n",
+    "library(tidymodels)\r\n"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "NLMycgG-9ezO"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 2. O conjunto de dados de diabetes\n",
+    "\n",
+    "Neste exercício, vamos demonstrar nossas habilidades de regressão fazendo previsões em um conjunto de dados de diabetes. O [conjunto de dados de diabetes](https://www4.stat.ncsu.edu/~boos/var.select/diabetes.rwrite1.txt) inclui `442 amostras` de dados relacionados ao diabetes, com 10 variáveis preditoras, `idade`, `sexo`, `índice de massa corporal`, `pressão arterial média` e `seis medições de soro sanguíneo`, além de uma variável de resultado `y`: uma medida quantitativa da progressão da doença um ano após a linha de base.\n",
+    "\n",
+    "|Número de observações|442|\n",
+    "|----------------------|:---|\n",
+    "|Número de preditores|As primeiras 10 colunas são preditivas numéricas|\n",
+    "|Resultado/Alvo|A coluna 11 é uma medida quantitativa da progressão da doença um ano após a linha de base|\n",
+    "|Informações dos preditores|- idade em anos\n",
+    "||- sexo\n",
+    "||- bmi índice de massa corporal\n",
+    "||- bp pressão arterial média\n",
+    "||- s1 tc, colesterol total no soro\n",
+    "||- s2 ldl, lipoproteínas de baixa densidade\n",
+    "||- s3 hdl, lipoproteínas de alta densidade\n",
+    "||- s4 tch, colesterol total / HDL\n",
+    "||- s5 ltg, possivelmente logaritmo do nível de triglicerídeos no soro\n",
+    "||- s6 glu, nível de açúcar no sangue|\n",
+    "\n",
+    "> 🎓 Lembre-se, isso é aprendizado supervisionado, e precisamos de um alvo chamado 'y'.\n",
+    "\n",
+    "Antes de manipular os dados com R, você precisa importar os dados para a memória do R ou estabelecer uma conexão com os dados que o R possa usar para acessá-los remotamente.\n",
+    "\n",
+    "> O pacote [readr](https://readr.tidyverse.org/), que faz parte do Tidyverse, oferece uma maneira rápida e amigável de ler dados retangulares no R.\n",
+    "\n",
+    "Agora, vamos carregar o conjunto de dados de diabetes fornecido neste URL de origem: <https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html>\n",
+    "\n",
+    "Além disso, faremos uma verificação básica nos dados usando `glimpse()` e exibiremos as primeiras 5 linhas usando `slice()`.\n",
+    "\n",
+    "Antes de prosseguir, vamos também introduzir algo que você encontrará frequentemente no código R 🥁🥁: o operador pipe `%>%`\n",
+    "\n",
+    "O operador pipe (`%>%`) realiza operações em sequência lógica, passando um objeto para frente em uma função ou expressão de chamada. Você pode pensar no operador pipe como dizendo \"e então\" no seu código.\n"
+   ],
+   "metadata": {
+    "id": "KM6iXLH996Cl"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Import the data set\r\n",
+    "diabetes <- read_table2(file = \"https://www4.stat.ncsu.edu/~boos/var.select/diabetes.rwrite1.txt\")\r\n",
+    "\r\n",
+    "\r\n",
+    "# Get a glimpse and dimensions of the data\r\n",
+    "glimpse(diabetes)\r\n",
+    "\r\n",
+    "\r\n",
+    "# Select the first 5 rows of the data\r\n",
+    "diabetes %>% \r\n",
+    "  slice(1:5)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "Z1geAMhM-bSP"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "`glimpse()` nos mostra que esses dados possuem 442 linhas e 11 colunas, com todas as colunas sendo do tipo de dado `double`.\n",
+    "\n",
+    "<br>\n",
+    "\n",
+    "> glimpse() e slice() são funções do [`dplyr`](https://dplyr.tidyverse.org/). Dplyr, parte do Tidyverse, é uma gramática de manipulação de dados que fornece um conjunto consistente de verbos para ajudar a resolver os desafios mais comuns de manipulação de dados.\n",
+    "\n",
+    "<br>\n",
+    "\n",
+    "Agora que temos os dados, vamos focar em uma única característica (`bmi`) como alvo para este exercício. Isso exigirá que selecionemos as colunas desejadas. Então, como fazemos isso?\n",
+    "\n",
+    "[`dplyr::select()`](https://dplyr.tidyverse.org/reference/select.html) nos permite *selecionar* (e opcionalmente renomear) colunas em um data frame.\n"
+   ],
+   "metadata": {
+    "id": "UwjVT1Hz-c3Z"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Select predictor feature `bmi` and outcome `y`\r\n",
+    "diabetes_select <- diabetes %>% \r\n",
+    "  select(c(bmi, y))\r\n",
+    "\r\n",
+    "# Print the first 5 rows\r\n",
+    "diabetes_select %>% \r\n",
+    "  slice(1:10)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "RDY1oAKI-m80"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 3. Dados de Treinamento e Teste\n",
+    "\n",
+    "É uma prática comum em aprendizado supervisionado *dividir* os dados em dois subconjuntos: um conjunto (geralmente maior) para treinar o modelo e um conjunto menor \"reservado\" para verificar como o modelo se saiu.\n",
+    "\n",
+    "Agora que temos os dados prontos, podemos verificar se uma máquina pode ajudar a determinar uma divisão lógica entre os números neste conjunto de dados. Podemos usar o pacote [rsample](https://tidymodels.github.io/rsample/), que faz parte do framework Tidymodels, para criar um objeto que contém as informações sobre *como* dividir os dados, e então usar mais duas funções do rsample para extrair os conjuntos de treinamento e teste criados:\n"
+   ],
+   "metadata": {
+    "id": "SDk668xK-tc3"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "set.seed(2056)\r\n",
+    "# Split 67% of the data for training and the rest for tesing\r\n",
+    "diabetes_split <- diabetes_select %>% \r\n",
+    "  initial_split(prop = 0.67)\r\n",
+    "\r\n",
+    "# Extract the resulting train and test sets\r\n",
+    "diabetes_train <- training(diabetes_split)\r\n",
+    "diabetes_test <- testing(diabetes_split)\r\n",
+    "\r\n",
+    "# Print the first 3 rows of the training set\r\n",
+    "diabetes_train %>% \r\n",
+    "  slice(1:10)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "EqtHx129-1h-"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 4. Treinar um modelo de regressão linear com Tidymodels\n",
+    "\n",
+    "Agora estamos prontos para treinar nosso modelo!\n",
+    "\n",
+    "No Tidymodels, você especifica modelos usando `parsnip()` ao definir três conceitos:\n",
+    "\n",
+    "-   O **tipo** do modelo diferencia modelos como regressão linear, regressão logística, modelos de árvore de decisão, entre outros.\n",
+    "\n",
+    "-   O **modo** do modelo inclui opções comuns como regressão e classificação; alguns tipos de modelo suportam ambos, enquanto outros possuem apenas um modo.\n",
+    "\n",
+    "-   O **motor** do modelo é a ferramenta computacional que será usada para ajustar o modelo. Frequentemente, são pacotes do R, como **`\"lm\"`** ou **`\"ranger\"`**.\n",
+    "\n",
+    "Essas informações de modelagem são capturadas em uma especificação de modelo, então vamos criar uma!\n"
+   ],
+   "metadata": {
+    "id": "sBOS-XhB-6v7"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Build a linear model specification\r\n",
+    "lm_spec <- \r\n",
+    "  # Type\r\n",
+    "  linear_reg() %>% \r\n",
+    "  # Engine\r\n",
+    "  set_engine(\"lm\") %>% \r\n",
+    "  # Mode\r\n",
+    "  set_mode(\"regression\")\r\n",
+    "\r\n",
+    "\r\n",
+    "# Print the model specification\r\n",
+    "lm_spec"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "20OwEw20--t3"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Depois que um modelo foi *especificado*, ele pode ser `estimado` ou `treinado` usando a função [`fit()`](https://parsnip.tidymodels.org/reference/fit.html), geralmente utilizando uma fórmula e alguns dados.\n",
+    "\n",
+    "`y ~ .` significa que ajustaremos `y` como a quantidade/objetivo previsto, explicado por todos os preditores/características, ou seja, `.` (neste caso, temos apenas um preditor: `bmi`).\n"
+   ],
+   "metadata": {
+    "id": "_oDHs89k_CJj"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Build a linear model specification\r\n",
+    "lm_spec <- linear_reg() %>% \r\n",
+    "  set_engine(\"lm\") %>%\r\n",
+    "  set_mode(\"regression\")\r\n",
+    "\r\n",
+    "\r\n",
+    "# Train a linear regression model\r\n",
+    "lm_mod <- lm_spec %>% \r\n",
+    "  fit(y ~ ., data = diabetes_train)\r\n",
+    "\r\n",
+    "# Print the model\r\n",
+    "lm_mod"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "YlsHqd-q_GJQ"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "A partir do resultado do modelo, podemos observar os coeficientes aprendidos durante o treinamento. Eles representam os coeficientes da linha de melhor ajuste que nos dá o menor erro geral entre a variável real e a prevista.  \n",
+    "<br>\n",
+    "\n",
+    "## 5. Fazer previsões no conjunto de teste\n",
+    "\n",
+    "Agora que treinamos um modelo, podemos usá-lo para prever a progressão da doença y para o conjunto de dados de teste usando [parsnip::predict()](https://parsnip.tidymodels.org/reference/predict.model_fit.html). Isso será usado para traçar a linha entre os grupos de dados.\n"
+   ],
+   "metadata": {
+    "id": "kGZ22RQj_Olu"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Make predictions for the test set\r\n",
+    "predictions <- lm_mod %>% \r\n",
+    "  predict(new_data = diabetes_test)\r\n",
+    "\r\n",
+    "# Print out some of the predictions\r\n",
+    "predictions %>% \r\n",
+    "  slice(1:5)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "nXHbY7M2_aao"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Uhuu! 💃🕺 Acabamos de treinar um modelo e usá-lo para fazer previsões!\n",
+    "\n",
+    "Ao fazer previsões, a convenção do tidymodels é sempre produzir um tibble/data frame de resultados com nomes de colunas padronizados. Isso facilita a combinação dos dados originais com as previsões em um formato utilizável para operações subsequentes, como criação de gráficos.\n",
+    "\n",
+    "`dplyr::bind_cols()` une de forma eficiente várias data frames por coluna.\n"
+   ],
+   "metadata": {
+    "id": "R_JstwUY_bIs"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Combine the predictions and the original test set\r\n",
+    "results <- diabetes_test %>% \r\n",
+    "  bind_cols(predictions)\r\n",
+    "\r\n",
+    "\r\n",
+    "results %>% \r\n",
+    "  slice(1:5)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "RybsMJR7_iI8"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 6. Plotar resultados do modelo\n",
+    "\n",
+    "Agora é hora de visualizar isso 📈. Vamos criar um gráfico de dispersão com todos os valores de `y` e `bmi` do conjunto de teste e, em seguida, usar as previsões para desenhar uma linha no lugar mais apropriado, entre os agrupamentos de dados do modelo.\n",
+    "\n",
+    "O R possui vários sistemas para criar gráficos, mas o `ggplot2` é um dos mais elegantes e versáteis. Ele permite que você componha gráficos **combinando componentes independentes**.\n"
+   ],
+   "metadata": {
+    "id": "XJbYbMZW_n_s"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Set a theme for the plot\r\n",
+    "theme_set(theme_light())\r\n",
+    "# Create a scatter plot\r\n",
+    "results %>% \r\n",
+    "  ggplot(aes(x = bmi)) +\r\n",
+    "  # Add a scatter plot\r\n",
+    "  geom_point(aes(y = y), size = 1.6) +\r\n",
+    "  # Add a line plot\r\n",
+    "  geom_line(aes(y = .pred), color = \"blue\", size = 1.5)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "R9tYp3VW_sTn"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "✅ Pense um pouco sobre o que está acontecendo aqui. Uma linha reta está passando por vários pequenos pontos de dados, mas o que exatamente ela está fazendo? Você consegue perceber como deveria ser possível usar essa linha para prever onde um novo ponto de dados, ainda não visto, deveria se encaixar em relação ao eixo y do gráfico? Tente colocar em palavras o uso prático desse modelo.\n",
+    "\n",
+    "Parabéns, você construiu seu primeiro modelo de regressão linear, fez uma previsão com ele e a exibiu em um gráfico!\n"
+   ],
+   "metadata": {
+    "id": "zrPtHIxx_tNI"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n---\n\n**Aviso Legal**:  \nEste documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.\n"
+   ]
+  }
+ ]
+}

translations/pt-BR/2-Regression/2-Data/README.md

@@ -0,0 +1,217 @@
+# Construir um modelo de regressão usando Scikit-learn: preparar e visualizar dados
+
+![Infográfico de visualização de dados](../../../../2-Regression/2-Data/images/data-visualization.png)
+
+Infográfico por [Dasani Madipalli](https://twitter.com/dasani_decoded)
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+> ### [Esta lição está disponível em R!](../../../../2-Regression/2-Data/solution/R/lesson_2.html)
+
+## Introdução
+
+Agora que você está equipado com as ferramentas necessárias para começar a construir modelos de aprendizado de máquina com Scikit-learn, está pronto para começar a fazer perguntas sobre seus dados. Ao trabalhar com dados e aplicar soluções de aprendizado de máquina, é muito importante saber como fazer as perguntas certas para desbloquear adequadamente o potencial do seu conjunto de dados.
+
+Nesta lição, você aprenderá:
+
+- Como preparar seus dados para a construção de modelos.
+- Como usar o Matplotlib para visualização de dados.
+
+## Fazendo as perguntas certas sobre seus dados
+
+A pergunta que você precisa responder determinará o tipo de algoritmos de aprendizado de máquina que você usará. E a qualidade da resposta que você obtém dependerá muito da natureza dos seus dados.
+
+Dê uma olhada nos [dados](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) fornecidos para esta lição. Você pode abrir este arquivo .csv no VS Code. Uma rápida olhada mostra imediatamente que há lacunas e uma mistura de dados em formato de texto e numérico. Há também uma coluna estranha chamada 'Package', onde os dados são uma mistura de 'sacks', 'bins' e outros valores. Os dados, na verdade, estão um pouco bagunçados.
+
+[![ML para iniciantes - Como analisar e limpar um conjunto de dados](https://img.youtube.com/vi/5qGjczWTrDQ/0.jpg)](https://youtu.be/5qGjczWTrDQ "ML para iniciantes - Como analisar e limpar um conjunto de dados")
+
+> 🎥 Clique na imagem acima para assistir a um vídeo curto sobre como preparar os dados para esta lição.
+
+Na verdade, não é muito comum receber um conjunto de dados completamente pronto para criar um modelo de aprendizado de máquina. Nesta lição, você aprenderá como preparar um conjunto de dados bruto usando bibliotecas padrão do Python. Você também aprenderá várias técnicas para visualizar os dados.
+
+## Estudo de caso: 'o mercado de abóboras'
+
+Nesta pasta, você encontrará um arquivo .csv na pasta raiz `data` chamado [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv), que inclui 1757 linhas de dados sobre o mercado de abóboras, organizados em agrupamentos por cidade. Estes são dados brutos extraídos dos [Relatórios Padrão dos Mercados de Produtos Especiais](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuídos pelo Departamento de Agricultura dos Estados Unidos.
+
+### Preparando os dados
+
+Esses dados estão em domínio público. Eles podem ser baixados em vários arquivos separados, por cidade, no site do USDA. Para evitar muitos arquivos separados, concatenamos todos os dados das cidades em uma única planilha, ou seja, já _preparamos_ um pouco os dados. Agora, vamos dar uma olhada mais de perto nos dados.
+
+### Os dados das abóboras - primeiras conclusões
+
+O que você percebe sobre esses dados? Você já viu que há uma mistura de textos, números, lacunas e valores estranhos que você precisa interpretar.
+
+Que pergunta você pode fazer sobre esses dados, usando uma técnica de regressão? Que tal "Prever o preço de uma abóbora à venda durante um determinado mês"? Olhando novamente para os dados, há algumas mudanças que você precisa fazer para criar a estrutura de dados necessária para essa tarefa.
+
+## Exercício - analisar os dados das abóboras
+
+Vamos usar o [Pandas](https://pandas.pydata.org/) (o nome significa `Python Data Analysis`), uma ferramenta muito útil para modelar dados, para analisar e preparar esses dados de abóboras.
+
+### Primeiro, verifique se há datas ausentes
+
+Você precisará primeiro tomar medidas para verificar se há datas ausentes:
+
+1. Converta as datas para o formato de mês (estas são datas dos EUA, então o formato é `MM/DD/YYYY`).
+2. Extraia o mês para uma nova coluna.
+
+Abra o arquivo _notebook.ipynb_ no Visual Studio Code e importe a planilha para um novo dataframe do Pandas.
+
+1. Use a função `head()` para visualizar as cinco primeiras linhas.
+
+    ```python
+    import pandas as pd
+    pumpkins = pd.read_csv('../data/US-pumpkins.csv')
+    pumpkins.head()
+    ```
+
+    ✅ Qual função você usaria para visualizar as últimas cinco linhas?
+
+1. Verifique se há dados ausentes no dataframe atual:
+
+    ```python
+    pumpkins.isnull().sum()
+    ```
+
+    Há dados ausentes, mas talvez isso não importe para a tarefa em questão.
+
+1. Para tornar seu dataframe mais fácil de trabalhar, selecione apenas as colunas necessárias, usando a função `loc`, que extrai do dataframe original um grupo de linhas (passado como primeiro parâmetro) e colunas (passado como segundo parâmetro). A expressão `:` no caso abaixo significa "todas as linhas".
+
+    ```python
+    columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
+    pumpkins = pumpkins.loc[:, columns_to_select]
+    ```
+
+### Segundo, determine o preço médio da abóbora
+
+Pense em como determinar o preço médio de uma abóbora em um determinado mês. Quais colunas você escolheria para essa tarefa? Dica: você precisará de 3 colunas.
+
+Solução: calcule a média das colunas `Low Price` e `High Price` para preencher a nova coluna Price e converta a coluna Date para mostrar apenas o mês. Felizmente, de acordo com a verificação acima, não há dados ausentes para datas ou preços.
+
+1. Para calcular a média, adicione o seguinte código:
+
+    ```python
+    price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
+
+    month = pd.DatetimeIndex(pumpkins['Date']).month
+
+    ```
+
+   ✅ Sinta-se à vontade para imprimir qualquer dado que desejar verificar usando `print(month)`.
+
+2. Agora, copie seus dados convertidos para um novo dataframe do Pandas:
+
+    ```python
+    new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
+    ```
+
+    Imprimir seu dataframe mostrará um conjunto de dados limpo e organizado, no qual você pode construir seu novo modelo de regressão.
+
+### Mas espere! Há algo estranho aqui
+
+Se você olhar para a coluna `Package`, verá que as abóboras são vendidas em muitas configurações diferentes. Algumas são vendidas em medidas de '1 1/9 bushel', outras em '1/2 bushel', algumas por unidade, algumas por peso e outras em grandes caixas com larguras variadas.
+
+> Parece que é muito difícil pesar abóboras de forma consistente
+
+Ao investigar os dados originais, é interessante notar que qualquer coisa com `Unit of Sale` igual a 'EACH' ou 'PER BIN' também tem o tipo `Package` por polegada, por bin ou 'each'. Parece que é muito difícil pesar abóboras de forma consistente, então vamos filtrá-las selecionando apenas abóboras com a string 'bushel' na coluna `Package`.
+
+1. Adicione um filtro no início do arquivo, sob a importação inicial do .csv:
+
+    ```python
+    pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
+    ```
+
+    Se você imprimir os dados agora, verá que está obtendo apenas cerca de 415 linhas de dados contendo abóboras por bushel.
+
+### Mas espere! Há mais uma coisa a fazer
+
+Você percebeu que a quantidade de bushel varia por linha? Você precisa normalizar os preços para mostrar o preço por bushel, então faça alguns cálculos para padronizá-los.
+
+1. Adicione estas linhas após o bloco que cria o dataframe new_pumpkins:
+
+    ```python
+    new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
+
+    new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
+    ```
+
+✅ De acordo com [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), o peso de um bushel depende do tipo de produto, pois é uma medida de volume. "Um bushel de tomates, por exemplo, deve pesar 56 libras... Folhas e verduras ocupam mais espaço com menos peso, então um bushel de espinafre pesa apenas 20 libras." É tudo muito complicado! Vamos evitar fazer uma conversão de bushel para libra e, em vez disso, precificar por bushel. Todo esse estudo sobre bushels de abóboras, no entanto, mostra como é muito importante entender a natureza dos seus dados!
+
+Agora, você pode analisar os preços por unidade com base na medida de bushel. Se você imprimir os dados mais uma vez, verá como eles estão padronizados.
+
+✅ Você percebeu que abóboras vendidas por meio bushel são muito caras? Consegue descobrir por quê? Dica: abóboras pequenas são muito mais caras do que grandes, provavelmente porque há muito mais delas por bushel, dado o espaço não utilizado ocupado por uma grande abóbora oca para torta.
+
+## Estratégias de visualização
+
+Parte do papel do cientista de dados é demonstrar a qualidade e a natureza dos dados com os quais está trabalhando. Para isso, eles frequentemente criam visualizações interessantes, como gráficos, diagramas e tabelas, mostrando diferentes aspectos dos dados. Dessa forma, eles conseguem mostrar visualmente relações e lacunas que, de outra forma, seriam difíceis de identificar.
+
+[![ML para iniciantes - Como visualizar dados com Matplotlib](https://img.youtube.com/vi/SbUkxH6IJo0/0.jpg)](https://youtu.be/SbUkxH6IJo0 "ML para iniciantes - Como visualizar dados com Matplotlib")
+
+> 🎥 Clique na imagem acima para assistir a um vídeo curto sobre como visualizar os dados para esta lição.
+
+As visualizações também podem ajudar a determinar a técnica de aprendizado de máquina mais apropriada para os dados. Um gráfico de dispersão que parece seguir uma linha, por exemplo, indica que os dados são bons candidatos para um exercício de regressão linear.
+
+Uma biblioteca de visualização de dados que funciona bem em notebooks Jupyter é o [Matplotlib](https://matplotlib.org/) (que você também viu na lição anterior).
+
+> Obtenha mais experiência com visualização de dados nestes [tutoriais](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott).
+
+## Exercício - experimente o Matplotlib
+
+Tente criar alguns gráficos básicos para exibir o novo dataframe que você acabou de criar. O que um gráfico de linha básico mostraria?
+
+1. Importe o Matplotlib no início do arquivo, sob a importação do Pandas:
+
+    ```python
+    import matplotlib.pyplot as plt
+    ```
+
+1. Execute novamente todo o notebook para atualizar.
+1. No final do notebook, adicione uma célula para plotar os dados como um boxplot:
+
+    ```python
+    price = new_pumpkins.Price
+    month = new_pumpkins.Month
+    plt.scatter(price, month)
+    plt.show()
+    ```
+
+    ![Um gráfico de dispersão mostrando a relação entre preço e mês](../../../../2-Regression/2-Data/images/scatterplot.png)
+
+    Este gráfico é útil? Algo nele te surpreende?
+
+    Não é particularmente útil, pois tudo o que faz é exibir seus dados como uma distribuição de pontos em um determinado mês.
+
+### Torne-o útil
+
+Para que os gráficos exibam dados úteis, geralmente é necessário agrupar os dados de alguma forma. Vamos tentar criar um gráfico onde o eixo y mostra os meses e os dados demonstram a distribuição.
+
+1. Adicione uma célula para criar um gráfico de barras agrupado:
+
+    ```python
+    new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
+    plt.ylabel("Pumpkin Price")
+    ```
+
+    ![Um gráfico de barras mostrando a relação entre preço e mês](../../../../2-Regression/2-Data/images/barchart.png)
+
+    Este é um gráfico de visualização de dados mais útil! Parece indicar que o preço mais alto das abóboras ocorre em setembro e outubro. Isso corresponde à sua expectativa? Por quê?
+
+---
+
+## 🚀Desafio
+
+Explore os diferentes tipos de visualização que o Matplotlib oferece. Quais tipos são mais apropriados para problemas de regressão?
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+## Revisão e Autoestudo
+
+Dê uma olhada nas várias maneiras de visualizar dados. Faça uma lista das diferentes bibliotecas disponíveis e anote quais são melhores para determinados tipos de tarefas, por exemplo, visualizações 2D versus visualizações 3D. O que você descobre?
+
+## Tarefa
+
+[Explorando visualização](assignment.md)
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/2-Data/assignment.md

@@ -0,0 +1,14 @@
+# Explorando Visualizações
+
+Existem várias bibliotecas disponíveis para visualização de dados. Crie algumas visualizações usando os dados de Pumpkin nesta lição com matplotlib e seaborn em um notebook de exemplo. Quais bibliotecas são mais fáceis de usar?
+
+## Rubrica
+
+| Critério | Exemplary | Adequado | Precisa de Melhorias |
+| -------- | --------- | -------- | -------------------- |
+|          | Um notebook é enviado com duas explorações/visualizações         | Um notebook é enviado com uma exploração/visualização       | Um notebook não é enviado                 |
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/2-Data/notebook.ipynb

@@ -0,0 +1,46 @@
+{
+ "metadata": {
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.3-final"
+  },
+  "orig_nbformat": 2,
+  "kernelspec": {
+   "name": "python3",
+   "display_name": "Python 3",
+   "language": "python"
+  },
+  "coopTranslator": {
+   "original_hash": "1b2ab303ac6c604a34c6ca7a49077fc7",
+   "translation_date": "2025-08-29T23:10:40+00:00",
+   "source_file": "2-Regression/2-Data/notebook.ipynb",
+   "language_code": "br"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2,
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n---\n\n**Aviso Legal**:  \nEste documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.\n"
+   ]
+  }
+ ]
+}

translations/pt-BR/2-Regression/2-Data/solution/Julia/README.md

@@ -0,0 +1,6 @@
+
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/2-Data/solution/R/lesson_2-R.ipynb

@@ -0,0 +1,668 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 2,
+ "metadata": {
+  "colab": {
+   "name": "lesson_2-R.ipynb",
+   "provenance": [],
+   "collapsed_sections": [],
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "name": "ir",
+   "display_name": "R"
+  },
+  "language_info": {
+   "name": "R"
+  },
+  "coopTranslator": {
+   "original_hash": "f3c335f9940cfd76528b3ef918b9b342",
+   "translation_date": "2025-08-29T23:16:14+00:00",
+   "source_file": "2-Regression/2-Data/solution/R/lesson_2-R.ipynb",
+   "language_code": "br"
+  }
+ },
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Construir um modelo de regressão: preparar e visualizar dados\n",
+    "\n",
+    "## **Regressão Linear para Abóboras - Aula 2**\n",
+    "#### Introdução\n",
+    "\n",
+    "Agora que você já está equipado com as ferramentas necessárias para começar a construir modelos de aprendizado de máquina com Tidymodels e o Tidyverse, está pronto para começar a fazer perguntas sobre seus dados. Ao trabalhar com dados e aplicar soluções de aprendizado de máquina, é muito importante entender como formular a pergunta certa para desbloquear adequadamente o potencial do seu conjunto de dados.\n",
+    "\n",
+    "Nesta aula, você aprenderá:\n",
+    "\n",
+    "-   Como preparar seus dados para a construção de modelos.\n",
+    "\n",
+    "-   Como usar `ggplot2` para visualização de dados.\n",
+    "\n",
+    "A pergunta que você precisa responder determinará o tipo de algoritmos de aprendizado de máquina que você utilizará. E a qualidade da resposta que você obtiver dependerá fortemente da natureza dos seus dados.\n",
+    "\n",
+    "Vamos ver isso na prática por meio de um exercício.\n",
+    "\n",
+    "<p >\n",
+    "   <img src=\"../../images/unruly_data.jpg\"\n",
+    "   width=\"700\"/>\n",
+    "   <figcaption>Arte por @allison_horst</figcaption>\n"
+   ],
+   "metadata": {
+    "id": "Pg5aexcOPqAZ"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 1. Importando dados de abóboras e invocando o Tidyverse\n",
+    "\n",
+    "Vamos precisar dos seguintes pacotes para explorar e manipular esta lição:\n",
+    "\n",
+    "-   `tidyverse`: O [tidyverse](https://www.tidyverse.org/) é uma [coleção de pacotes R](https://www.tidyverse.org/packages) projetada para tornar a ciência de dados mais rápida, fácil e divertida!\n",
+    "\n",
+    "Você pode instalá-los assim:\n",
+    "\n",
+    "`install.packages(c(\"tidyverse\"))`\n",
+    "\n",
+    "O script abaixo verifica se você possui os pacotes necessários para completar este módulo e os instala para você caso algum esteja faltando.\n"
+   ],
+   "metadata": {
+    "id": "dc5WhyVdXAjR"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\n",
+    "pacman::p_load(tidyverse)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "GqPYUZgfXOBt"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Agora, vamos iniciar alguns pacotes e carregar os [dados](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) fornecidos para esta lição!\n"
+   ],
+   "metadata": {
+    "id": "kvjDTPDSXRr2"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Load the core Tidyverse packages\n",
+    "library(tidyverse)\n",
+    "\n",
+    "# Import the pumpkins data\n",
+    "pumpkins <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/2-Regression/data/US-pumpkins.csv\")\n",
+    "\n",
+    "\n",
+    "# Get a glimpse and dimensions of the data\n",
+    "glimpse(pumpkins)\n",
+    "\n",
+    "\n",
+    "# Print the first 50 rows of the data set\n",
+    "pumpkins %>% \n",
+    "  slice_head(n =50)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "VMri-t2zXqgD"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Um rápido `glimpse()` mostra imediatamente que há valores em branco e uma mistura de strings (`chr`) e dados numéricos (`dbl`). A coluna `Date` está no formato de texto e há também uma coluna estranha chamada `Package`, onde os dados são uma mistura de `sacks`, `bins` e outros valores. Na verdade, os dados estão um pouco bagunçados 😤.\n",
+    "\n",
+    "De fato, não é muito comum receber um conjunto de dados completamente pronto para ser usado na criação de um modelo de ML diretamente. Mas não se preocupe, nesta lição, você aprenderá como preparar um conjunto de dados bruto usando bibliotecas padrão do R 🧑‍🔧. Você também aprenderá várias técnicas para visualizar os dados. 📈📊\n",
+    "<br>\n",
+    "\n",
+    "> Um lembrete: O operador pipe (`%>%`) realiza operações em sequência lógica, passando um objeto adiante para uma função ou expressão. Você pode pensar no operador pipe como se estivesse dizendo \"e então\" no seu código.\n"
+   ],
+   "metadata": {
+    "id": "REWcIv9yX29v"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 2. Verificar dados ausentes\n",
+    "\n",
+    "Um dos problemas mais comuns que os cientistas de dados precisam lidar é com dados incompletos ou ausentes. O R representa valores ausentes ou desconhecidos com um valor especial chamado sentinela: `NA` (Not Available).\n",
+    "\n",
+    "Então, como saberíamos que o data frame contém valores ausentes?  \n",
+    "<br>\n",
+    "-   Uma maneira direta seria usar a função base do R `anyNA`, que retorna os objetos lógicos `TRUE` ou `FALSE`.\n"
+   ],
+   "metadata": {
+    "id": "Zxfb3AM5YbUe"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "pumpkins %>% \n",
+    "  anyNA()"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "G--DQutAYltj"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Ótimo, parece que há alguns dados faltando! Esse é um bom ponto de partida.\n",
+    "\n",
+    "-   Outra maneira seria usar a função `is.na()`, que indica quais elementos individuais da coluna estão ausentes com um valor lógico `TRUE`.\n"
+   ],
+   "metadata": {
+    "id": "mU-7-SB6YokF"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "pumpkins %>% \n",
+    "  is.na() %>% \n",
+    "  head(n = 7)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "W-DxDOR4YxSW"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Certo, trabalho concluído, mas com um dataframe tão grande como este, seria ineficiente e praticamente impossível revisar todas as linhas e colunas individualmente😴.\n",
+    "\n",
+    "-   Uma maneira mais intuitiva seria calcular a soma dos valores ausentes para cada coluna:\n"
+   ],
+   "metadata": {
+    "id": "xUWxipKYY0o7"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "pumpkins %>% \n",
+    "  is.na() %>% \n",
+    "  colSums()"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "ZRBWV6P9ZArL"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Muito melhor! Há dados faltando, mas talvez isso não importe para a tarefa em questão. Vamos ver o que uma análise mais aprofundada revela.\n",
+    "\n",
+    "> Junto com os incríveis conjuntos de pacotes e funções, o R possui uma documentação muito boa. Por exemplo, use `help(colSums)` ou `?colSums` para saber mais sobre a função.\n"
+   ],
+   "metadata": {
+    "id": "9gv-crB6ZD1Y"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 3. Dplyr: Uma Gramática para Manipulação de Dados\n",
+    "\n",
+    "<p >\n",
+    "   <img src=\"../../images/dplyr_wrangling.png\"\n",
+    "   width=\"569\"/>\n",
+    "   <figcaption>Arte por @allison_horst</figcaption>\n",
+    "\n",
+    "\n",
+    "<!--![Arte por \\@allison_horst](../../../../../../translated_images/pt-BR/dplyr_wrangling.f5f99c64fd4580f1.webp)<br/>Arte por \\@allison_horst-->\n"
+   ],
+   "metadata": {
+    "id": "o4jLY5-VZO2C"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "[`dplyr`](https://dplyr.tidyverse.org/), um pacote do Tidyverse, é uma gramática de manipulação de dados que oferece um conjunto consistente de verbos para ajudar a resolver os desafios mais comuns de manipulação de dados. Nesta seção, vamos explorar alguns dos verbos do dplyr!  \n",
+    "<br>\n"
+   ],
+   "metadata": {
+    "id": "i5o33MQBZWWw"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "#### dplyr::select()\n",
+    "\n",
+    "`select()` é uma função do pacote `dplyr` que ajuda você a escolher colunas para manter ou excluir.\n",
+    "\n",
+    "Para tornar seu data frame mais fácil de trabalhar, remova várias de suas colunas usando `select()`, mantendo apenas as colunas que você precisa.\n",
+    "\n",
+    "Por exemplo, neste exercício, nossa análise envolverá as colunas `Package`, `Low Price`, `High Price` e `Date`. Vamos selecionar essas colunas.\n"
+   ],
+   "metadata": {
+    "id": "x3VGMAGBZiUr"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Select desired columns\n",
+    "pumpkins <- pumpkins %>% \n",
+    "  select(Package, `Low Price`, `High Price`, Date)\n",
+    "\n",
+    "\n",
+    "# Print data set\n",
+    "pumpkins %>% \n",
+    "  slice_head(n = 5)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "F_FgxQnVZnM0"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "#### dplyr::mutate()\n",
+    "\n",
+    "`mutate()` é uma função do pacote `dplyr` que ajuda a criar ou modificar colunas, mantendo as colunas existentes.\n",
+    "\n",
+    "A estrutura geral do `mutate` é:\n",
+    "\n",
+    "`data %>%   mutate(nome_da_nova_coluna = o_que_ela_contem)`\n",
+    "\n",
+    "Vamos experimentar o `mutate` usando a coluna `Date` e realizando as seguintes operações:\n",
+    "\n",
+    "1. Converter as datas (atualmente do tipo caractere) para um formato de mês (essas são datas no formato dos EUA, ou seja, `MM/DD/YYYY`).\n",
+    "\n",
+    "2. Extrair o mês das datas para uma nova coluna.\n",
+    "\n",
+    "No R, o pacote [lubridate](https://lubridate.tidyverse.org/) facilita o trabalho com dados de data e hora. Então, vamos usar `dplyr::mutate()`, `lubridate::mdy()`, `lubridate::month()` e ver como alcançar os objetivos acima. Podemos descartar a coluna `Date`, já que não precisaremos mais dela nas operações subsequentes.\n"
+   ],
+   "metadata": {
+    "id": "2KKo0Ed9Z1VB"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Load lubridate\n",
+    "library(lubridate)\n",
+    "\n",
+    "pumpkins <- pumpkins %>% \n",
+    "  # Convert the Date column to a date object\n",
+    "  mutate(Date = mdy(Date)) %>% \n",
+    "  # Extract month from Date\n",
+    "  mutate(Month = month(Date)) %>% \n",
+    "  # Drop Date column\n",
+    "  select(-Date)\n",
+    "\n",
+    "# View the first few rows\n",
+    "pumpkins %>% \n",
+    "  slice_head(n = 7)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "5joszIVSZ6xe"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Uhuu! 🤩\n",
+    "\n",
+    "Agora, vamos criar uma nova coluna chamada `Price`, que representa o preço médio de uma abóbora. Para isso, vamos calcular a média das colunas `Low Price` e `High Price` para preencher a nova coluna Price.  \n",
+    "<br>\n"
+   ],
+   "metadata": {
+    "id": "nIgLjNMCZ-6Y"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Create a new column Price\n",
+    "pumpkins <- pumpkins %>% \n",
+    "  mutate(Price = (`Low Price` + `High Price`)/2)\n",
+    "\n",
+    "# View the first few rows of the data\n",
+    "pumpkins %>% \n",
+    "  slice_head(n = 5)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "Zo0BsqqtaJw2"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Yeees!💪\n",
+    "\n",
+    "\"Mas espere!\", você dirá depois de dar uma olhada rápida no conjunto de dados com `View(pumpkins)`, \"Tem algo estranho aqui!\"🤔\n",
+    "\n",
+    "Se você observar a coluna `Package`, verá que as abóboras são vendidas em várias configurações diferentes. Algumas são vendidas em medidas de `1 1/9 bushel`, outras em medidas de `1/2 bushel`, algumas por abóbora, outras por libra, e algumas em grandes caixas com larguras variadas.\n",
+    "\n",
+    "Vamos verificar isso:\n"
+   ],
+   "metadata": {
+    "id": "p77WZr-9aQAR"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Verify the distinct observations in Package column\n",
+    "pumpkins %>% \n",
+    "  distinct(Package)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "XISGfh0IaUy6"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Incrível!👏\n",
+    "\n",
+    "Parece que abóboras são muito difíceis de pesar de forma consistente, então vamos filtrá-las selecionando apenas as abóboras que contêm a string *bushel* na coluna `Package` e colocar isso em um novo data frame `new_pumpkins`.\n"
+   ],
+   "metadata": {
+    "id": "7sMjiVujaZxY"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "#### dplyr::filter() e stringr::str_detect()\n",
+    "\n",
+    "[`dplyr::filter()`](https://dplyr.tidyverse.org/reference/filter.html): cria um subconjunto dos dados contendo apenas as **linhas** que atendem às suas condições, neste caso, abóboras com a string *bushel* na coluna `Package`.\n",
+    "\n",
+    "[stringr::str_detect()](https://stringr.tidyverse.org/reference/str_detect.html): detecta a presença ou ausência de um padrão em uma string.\n",
+    "\n",
+    "O pacote [`stringr`](https://github.com/tidyverse/stringr) fornece funções simples para operações comuns com strings.\n"
+   ],
+   "metadata": {
+    "id": "L8Qfcs92ageF"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Retain only pumpkins with \"bushel\"\n",
+    "new_pumpkins <- pumpkins %>% \n",
+    "       filter(str_detect(Package, \"bushel\"))\n",
+    "\n",
+    "# Get the dimensions of the new data\n",
+    "dim(new_pumpkins)\n",
+    "\n",
+    "# View a few rows of the new data\n",
+    "new_pumpkins %>% \n",
+    "  slice_head(n = 5)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "hy_SGYREampd"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Você pode ver que reduzimos para cerca de 415 linhas de dados contendo abóboras por alqueire. 🤩\n"
+   ],
+   "metadata": {
+    "id": "VrDwF031avlR"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "#### dplyr::case_when()\n",
+    "\n",
+    "**Mas espere! Ainda há mais uma coisa a fazer**\n",
+    "\n",
+    "Você percebeu que a quantidade de alqueires varia por linha? É necessário normalizar os preços para que sejam exibidos por alqueire, e não por 1 1/9 ou 1/2 alqueire. Hora de fazer alguns cálculos para padronizar isso.\n",
+    "\n",
+    "Usaremos a função [`case_when()`](https://dplyr.tidyverse.org/reference/case_when.html) para *modificar* a coluna Price dependendo de algumas condições. `case_when` permite que você vetorize múltiplas declarações `if_else()`.\n"
+   ],
+   "metadata": {
+    "id": "mLpw2jH4a0tx"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Convert the price if the Package contains fractional bushel values\n",
+    "new_pumpkins <- new_pumpkins %>% \n",
+    "  mutate(Price = case_when(\n",
+    "    str_detect(Package, \"1 1/9\") ~ Price/(1 + 1/9),\n",
+    "    str_detect(Package, \"1/2\") ~ Price/(1/2),\n",
+    "    TRUE ~ Price))\n",
+    "\n",
+    "# View the first few rows of the data\n",
+    "new_pumpkins %>% \n",
+    "  slice_head(n = 30)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "P68kLVQmbM6I"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Agora, podemos analisar o preço por unidade com base na medida de alqueire. Todo esse estudo sobre alqueires de abóboras, no entanto, mostra como é `importante` `entender a natureza dos seus dados`!\n",
+    "\n",
+    "> ✅ De acordo com [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), o peso de um alqueire depende do tipo de produto, já que é uma medida de volume. \"Um alqueire de tomates, por exemplo, deve pesar 56 libras... Folhas e verduras ocupam mais espaço com menos peso, então um alqueire de espinafre pesa apenas 20 libras.\" É tudo bem complicado! Vamos evitar fazer uma conversão de alqueire para libra e, em vez disso, precificar pelo alqueire. Todo esse estudo sobre alqueires de abóboras, no entanto, mostra como é muito importante entender a natureza dos seus dados!\n",
+    ">\n",
+    "> ✅ Você percebeu que as abóboras vendidas por meio alqueire são muito caras? Consegue descobrir o motivo? Dica: abóboras pequenas são muito mais caras do que as grandes, provavelmente porque há muito mais delas por alqueire, considerando o espaço não utilizado ocupado por uma grande abóbora oca de torta.\n"
+   ],
+   "metadata": {
+    "id": "pS2GNPagbSdb"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Agora, por pura diversão 💁‍♀️, vamos também mover a coluna Mês para a primeira posição, ou seja, `antes` da coluna `Pacote`.\n",
+    "\n",
+    "`dplyr::relocate()` é usado para alterar as posições das colunas.\n"
+   ],
+   "metadata": {
+    "id": "qql1SowfbdnP"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Create a new data frame new_pumpkins\n",
+    "new_pumpkins <- new_pumpkins %>% \n",
+    "  relocate(Month, .before = Package)\n",
+    "\n",
+    "new_pumpkins %>% \n",
+    "  slice_head(n = 7)"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "JJ1x6kw8bixF"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Bom trabalho!👌 Agora você tem um conjunto de dados limpo e organizado para construir seu novo modelo de regressão!  \n",
+    "<br>\n"
+   ],
+   "metadata": {
+    "id": "y8TJ0Za_bn5Y"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## 4. Visualização de dados com ggplot2\n",
+    "\n",
+    "<p >\n",
+    "   <img src=\"../../images/data-visualization.png\"\n",
+    "   width=\"600\"/>\n",
+    "   <figcaption>Infográfico por Dasani Madipalli</figcaption>\n",
+    "\n",
+    "\n",
+    "<!--![Infográfico por Dasani Madipalli](../../../../../../translated_images/pt-BR/data-visualization.54e56dded7c1a804.webp){width=\"600\"}-->\n",
+    "\n",
+    "Existe um *sábio* ditado que diz o seguinte:\n",
+    "\n",
+    "> \"O gráfico simples trouxe mais informações à mente do analista de dados do que qualquer outro dispositivo.\" --- John Tukey\n",
+    "\n",
+    "Parte do papel do cientista de dados é demonstrar a qualidade e a natureza dos dados com os quais está trabalhando. Para isso, eles frequentemente criam visualizações interessantes, como gráficos, diagramas e tabelas, mostrando diferentes aspectos dos dados. Dessa forma, eles conseguem mostrar visualmente relações e lacunas que, de outra maneira, seriam difíceis de identificar.\n",
+    "\n",
+    "As visualizações também podem ajudar a determinar a técnica de aprendizado de máquina mais apropriada para os dados. Um gráfico de dispersão que parece seguir uma linha, por exemplo, indica que os dados são bons candidatos para um exercício de regressão linear.\n",
+    "\n",
+    "O R oferece vários sistemas para criar gráficos, mas [`ggplot2`](https://ggplot2.tidyverse.org/index.html) é um dos mais elegantes e versáteis. O `ggplot2` permite compor gráficos **combinando componentes independentes**.\n",
+    "\n",
+    "Vamos começar com um gráfico de dispersão simples para as colunas Price e Month.\n",
+    "\n",
+    "Neste caso, começaremos com [`ggplot()`](https://ggplot2.tidyverse.org/reference/ggplot.html), fornecendo um conjunto de dados e um mapeamento estético (com [`aes()`](https://ggplot2.tidyverse.org/reference/aes.html)) e, em seguida, adicionaremos camadas (como [`geom_point()`](https://ggplot2.tidyverse.org/reference/geom_point.html)) para gráficos de dispersão.\n"
+   ],
+   "metadata": {
+    "id": "mYSH6-EtbvNa"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Set a theme for the plots\n",
+    "theme_set(theme_light())\n",
+    "\n",
+    "# Create a scatter plot\n",
+    "p <- ggplot(data = new_pumpkins, aes(x = Price, y = Month))\n",
+    "p + geom_point()"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "g2YjnGeOcLo4"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Este é um gráfico útil 🤷? Algo nele te surpreende?\n",
+    "\n",
+    "Não é particularmente útil, já que tudo o que ele faz é mostrar seus dados como uma distribuição de pontos em um determinado mês.\n",
+    "<br>\n"
+   ],
+   "metadata": {
+    "id": "Ml7SDCLQcPvE"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### **Como tornamos isso útil?**\n",
+    "\n",
+    "Para exibir dados úteis em gráficos, geralmente é necessário agrupar os dados de alguma forma. Por exemplo, no nosso caso, calcular o preço médio das abóboras para cada mês forneceria mais insights sobre os padrões subjacentes em nossos dados. Isso nos leva a mais uma abordagem do **dplyr**:\n",
+    "\n",
+    "#### `dplyr::group_by() %>% summarize()`\n",
+    "\n",
+    "A agregação agrupada no R pode ser facilmente realizada usando\n",
+    "\n",
+    "`dplyr::group_by() %>% summarize()`\n",
+    "\n",
+    "-   `dplyr::group_by()` altera a unidade de análise do conjunto de dados completo para grupos individuais, como por mês.\n",
+    "\n",
+    "-   `dplyr::summarize()` cria um novo data frame com uma coluna para cada variável de agrupamento e uma coluna para cada estatística resumida que você especificou.\n",
+    "\n",
+    "Por exemplo, podemos usar `dplyr::group_by() %>% summarize()` para agrupar as abóboras com base na coluna **Month** e, em seguida, calcular o **preço médio** para cada mês.\n"
+   ],
+   "metadata": {
+    "id": "jMakvJZIcVkh"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Find the average price of pumpkins per month\r\n",
+    "new_pumpkins %>%\r\n",
+    "  group_by(Month) %>% \r\n",
+    "  summarise(mean_price = mean(Price))"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "6kVSUa2Bcilf"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Sucinto!✨\n",
+    "\n",
+    "Características categóricas, como meses, são melhor representadas usando um gráfico de barras 📊. As camadas responsáveis por gráficos de barras são `geom_bar()` e `geom_col()`. Consulte `?geom_bar` para saber mais.\n",
+    "\n",
+    "Vamos criar um agora!\n"
+   ],
+   "metadata": {
+    "id": "Kds48GUBcj3W"
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "source": [
+    "# Find the average price of pumpkins per month then plot a bar chart\r\n",
+    "new_pumpkins %>%\r\n",
+    "  group_by(Month) %>% \r\n",
+    "  summarise(mean_price = mean(Price)) %>% \r\n",
+    "  ggplot(aes(x = Month, y = mean_price)) +\r\n",
+    "  geom_col(fill = \"midnightblue\", alpha = 0.7) +\r\n",
+    "  ylab(\"Pumpkin Price\")"
+   ],
+   "outputs": [],
+   "metadata": {
+    "id": "VNbU1S3BcrxO"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "🤩🤩 Esta é uma visualização de dados mais útil! Parece indicar que o preço mais alto para abóboras ocorre em setembro e outubro. Isso atende às suas expectativas? Por que sim ou por que não?\n",
+    "\n",
+    "Parabéns por concluir a segunda lição 👏! Você preparou seus dados para a construção do modelo e, em seguida, descobriu mais insights usando visualizações!\n"
+   ],
+   "metadata": {
+    "id": "zDm0VOzzcuzR"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n---\n\n**Aviso Legal**:  \nEste documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte oficial. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.\n"
+   ]
+  }
+ ]
+}

translations/pt-BR/2-Regression/3-Linear/README.md

@@ -0,0 +1,371 @@
+# Construir um modelo de regressão usando Scikit-learn: regressão de quatro maneiras
+
+![Infográfico de regressão linear vs polinomial](../../../../2-Regression/3-Linear/images/linear-polynomial.png)
+> Infográfico por [Dasani Madipalli](https://twitter.com/dasani_decoded)
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+> ### [Esta lição está disponível em R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
+### Introdução 
+
+Até agora, você explorou o que é regressão com dados de exemplo coletados do conjunto de dados de preços de abóbora que usaremos ao longo desta lição. Você também os visualizou usando Matplotlib.
+
+Agora você está pronto para mergulhar mais fundo na regressão para aprendizado de máquina. Embora a visualização permita que você compreenda os dados, o verdadeiro poder do aprendizado de máquina vem do _treinamento de modelos_. Modelos são treinados com dados históricos para capturar automaticamente as dependências dos dados e permitem prever resultados para novos dados que o modelo ainda não viu.
+
+Nesta lição, você aprenderá mais sobre dois tipos de regressão: _regressão linear básica_ e _regressão polinomial_, juntamente com algumas das matemáticas subjacentes a essas técnicas. Esses modelos nos permitirão prever os preços das abóboras dependendo de diferentes dados de entrada.
+
+[![ML para iniciantes - Entendendo a Regressão Linear](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML para iniciantes - Entendendo a Regressão Linear")
+
+> 🎥 Clique na imagem acima para um breve vídeo sobre regressão linear.
+
+> Ao longo deste currículo, assumimos conhecimento mínimo de matemática e buscamos torná-lo acessível para estudantes de outras áreas. Fique atento a notas, 🧮 chamadas, diagramas e outras ferramentas de aprendizado para ajudar na compreensão.
+
+### Pré-requisito
+
+Você já deve estar familiarizado com a estrutura dos dados de abóbora que estamos analisando. Você pode encontrá-los pré-carregados e pré-limpos no arquivo _notebook.ipynb_ desta lição. No arquivo, o preço da abóbora é exibido por alqueire em um novo data frame. Certifique-se de que pode executar esses notebooks em kernels no Visual Studio Code.
+
+### Preparação
+
+Como lembrete, você está carregando esses dados para fazer perguntas sobre eles.
+
+- Qual é o melhor momento para comprar abóboras?
+- Qual preço posso esperar por uma caixa de abóboras em miniatura?
+- Devo comprá-las em cestas de meio alqueire ou em caixas de 1 1/9 alqueire?
+Vamos continuar explorando esses dados.
+
+Na lição anterior, você criou um data frame do Pandas e o preencheu com parte do conjunto de dados original, padronizando os preços por alqueire. Ao fazer isso, no entanto, você só conseguiu reunir cerca de 400 pontos de dados e apenas para os meses de outono.
+
+Dê uma olhada nos dados que pré-carregamos no notebook que acompanha esta lição. Os dados estão pré-carregados e um gráfico de dispersão inicial é traçado para mostrar os dados por mês. Talvez possamos obter um pouco mais de detalhes sobre a natureza dos dados ao limpá-los mais.
+
+## Uma linha de regressão linear
+
+Como você aprendeu na Lição 1, o objetivo de um exercício de regressão linear é ser capaz de traçar uma linha para:
+
+- **Mostrar relações entre variáveis**. Mostrar a relação entre variáveis
+- **Fazer previsões**. Fazer previsões precisas sobre onde um novo ponto de dados cairia em relação a essa linha.
+
+É típico da **Regressão de Mínimos Quadrados** traçar esse tipo de linha. O termo 'mínimos quadrados' significa que todos os pontos de dados ao redor da linha de regressão são elevados ao quadrado e depois somados. Idealmente, essa soma final é o menor possível, porque queremos um número baixo de erros, ou `mínimos quadrados`.
+
+Fazemos isso porque queremos modelar uma linha que tenha a menor distância cumulativa de todos os nossos pontos de dados. Também elevamos os termos ao quadrado antes de somá-los, pois estamos preocupados com sua magnitude, em vez de sua direção.
+
+> **🧮 Mostre-me a matemática** 
+> 
+> Esta linha, chamada de _linha de melhor ajuste_, pode ser expressa por [uma equação](https://en.wikipedia.org/wiki/Simple_linear_regression): 
+> 
+> ```
+> Y = a + bX
+> ```
+>
+> `X` é a 'variável explicativa'. `Y` é a 'variável dependente'. A inclinação da linha é `b` e `a` é o intercepto no eixo Y, que se refere ao valor de `Y` quando `X = 0`. 
+>
+>![calcular a inclinação](../../../../2-Regression/3-Linear/images/slope.png)
+>
+> Primeiro, calcule a inclinação `b`. Infográfico por [Jen Looper](https://twitter.com/jenlooper)
+>
+> Em outras palavras, e referindo-se à pergunta original dos dados de abóbora: "prever o preço de uma abóbora por alqueire por mês", `X` se referiria ao preço e `Y` ao mês de venda. 
+>
+>![completar a equação](../../../../2-Regression/3-Linear/images/calculation.png)
+>
+> Calcule o valor de Y. Se você está pagando cerca de $4, deve ser abril! Infográfico por [Jen Looper](https://twitter.com/jenlooper)
+>
+> A matemática que calcula a linha deve demonstrar a inclinação da linha, que também depende do intercepto, ou onde `Y` está situado quando `X = 0`.
+>
+> Você pode observar o método de cálculo desses valores no site [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Também visite [este calculador de mínimos quadrados](https://www.mathsisfun.com/data/least-squares-calculator.html) para ver como os valores dos números impactam a linha.
+
+## Correlação
+
+Outro termo importante para entender é o **Coeficiente de Correlação** entre as variáveis X e Y fornecidas. Usando um gráfico de dispersão, você pode visualizar rapidamente esse coeficiente. Um gráfico com pontos de dados espalhados em uma linha ordenada tem alta correlação, mas um gráfico com pontos de dados espalhados por toda parte entre X e Y tem baixa correlação.
+
+Um bom modelo de regressão linear será aquele que tem um Coeficiente de Correlação alto (mais próximo de 1 do que de 0) usando o método de Mínimos Quadrados com uma linha de regressão.
+
+✅ Execute o notebook que acompanha esta lição e observe o gráfico de dispersão de Mês para Preço. Os dados que associam Mês ao Preço para vendas de abóbora parecem ter alta ou baixa correlação, de acordo com sua interpretação visual do gráfico de dispersão? Isso muda se você usar uma medida mais detalhada em vez de `Mês`, como *dia do ano* (ou seja, número de dias desde o início do ano)?
+
+No código abaixo, assumiremos que limpamos os dados e obtivemos um data frame chamado `new_pumpkins`, semelhante ao seguinte:
+
+ID | Mês | DiaDoAno | Variedade | Cidade | Embalagem | Preço Baixo | Preço Alto | Preço
+---|-----|----------|-----------|--------|-----------|-------------|------------|-------
+70 | 9 | 267 | TIPO TORTA | BALTIMORE | 1 1/9 caixas de alqueire | 15.0 | 15.0 | 13.636364
+71 | 9 | 267 | TIPO TORTA | BALTIMORE | 1 1/9 caixas de alqueire | 18.0 | 18.0 | 16.363636
+72 | 10 | 274 | TIPO TORTA | BALTIMORE | 1 1/9 caixas de alqueire | 18.0 | 18.0 | 16.363636
+73 | 10 | 274 | TIPO TORTA | BALTIMORE | 1 1/9 caixas de alqueire | 17.0 | 17.0 | 15.454545
+74 | 10 | 281 | TIPO TORTA | BALTIMORE | 1 1/9 caixas de alqueire | 15.0 | 15.0 | 13.636364
+
+> O código para limpar os dados está disponível em [`notebook.ipynb`](../../../../2-Regression/3-Linear/notebook.ipynb). Realizamos os mesmos passos de limpeza da lição anterior e calculamos a coluna `DiaDoAno` usando a seguinte expressão: 
+
+```python
+day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
+```
+
+Agora que você entende a matemática por trás da regressão linear, vamos criar um modelo de regressão para ver se conseguimos prever qual embalagem de abóboras terá os melhores preços. Alguém comprando abóboras para um campo de abóboras de feriado pode querer essa informação para otimizar suas compras de embalagens de abóboras para o campo.
+
+## Procurando por Correlação
+
+[![ML para iniciantes - Procurando por Correlação: A Chave para Regressão Linear](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML para iniciantes - Procurando por Correlação: A Chave para Regressão Linear")
+
+> 🎥 Clique na imagem acima para um breve vídeo sobre correlação.
+
+Na lição anterior, você provavelmente viu que o preço médio para diferentes meses se parece com isto:
+
+<img alt="Preço médio por mês" src="../../../../translated_images/pt-BR/barchart.a833ea9194346d76.webp" width="50%"/>
+
+Isso sugere que deve haver alguma correlação, e podemos tentar treinar um modelo de regressão linear para prever a relação entre `Mês` e `Preço`, ou entre `DiaDoAno` e `Preço`. Aqui está o gráfico de dispersão que mostra a última relação:
+
+<img alt="Gráfico de dispersão de Preço vs. Dia do Ano" src="../../../../translated_images/pt-BR/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" /> 
+
+Vamos ver se há correlação usando a função `corr`:
+
+```python
+print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
+print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
+```
+
+Parece que a correlação é bem pequena, -0.15 por `Mês` e -0.17 por `DiaDoAno`, mas pode haver outra relação importante. Parece que há diferentes agrupamentos de preços correspondendo a diferentes variedades de abóbora. Para confirmar essa hipótese, vamos plotar cada categoria de abóbora usando uma cor diferente. Passando um parâmetro `ax` para a função de plotagem `scatter`, podemos plotar todos os pontos no mesmo gráfico:
+
+```python
+ax=None
+colors = ['red','blue','green','yellow']
+for i,var in enumerate(new_pumpkins['Variety'].unique()):
+    df = new_pumpkins[new_pumpkins['Variety']==var]
+    ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
+```
+
+<img alt="Gráfico de dispersão de Preço vs. Dia do Ano" src="../../../../translated_images/pt-BR/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" /> 
+
+Nossa investigação sugere que a variedade tem mais efeito no preço geral do que a data de venda. Podemos ver isso com um gráfico de barras:
+
+```python
+new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
+```
+
+<img alt="Gráfico de barras de preço vs variedade" src="../../../../translated_images/pt-BR/price-by-variety.744a2f9925d9bcb4.webp" width="50%" /> 
+
+Vamos focar por enquanto apenas em uma variedade de abóbora, o 'tipo torta', e ver qual efeito a data tem no preço:
+
+```python
+pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
+pie_pumpkins.plot.scatter('DayOfYear','Price') 
+```
+<img alt="Gráfico de dispersão de Preço vs. Dia do Ano" src="../../../../translated_images/pt-BR/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" /> 
+
+Se agora calcularmos a correlação entre `Preço` e `DiaDoAno` usando a função `corr`, obteremos algo como `-0.27` - o que significa que treinar um modelo preditivo faz sentido.
+
+> Antes de treinar um modelo de regressão linear, é importante garantir que nossos dados estejam limpos. A regressão linear não funciona bem com valores ausentes, portanto, faz sentido eliminar todas as células vazias:
+
+```python
+pie_pumpkins.dropna(inplace=True)
+pie_pumpkins.info()
+```
+
+Outra abordagem seria preencher esses valores vazios com valores médios da coluna correspondente.
+
+## Regressão Linear Simples
+
+[![ML para iniciantes - Regressão Linear e Polinomial usando Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML para iniciantes - Regressão Linear e Polinomial usando Scikit-learn")
+
+> 🎥 Clique na imagem acima para um breve vídeo sobre regressão linear e polinomial.
+
+Para treinar nosso modelo de regressão linear, usaremos a biblioteca **Scikit-learn**.
+
+```python
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error
+from sklearn.model_selection import train_test_split
+```
+
+Começamos separando os valores de entrada (features) e a saída esperada (label) em arrays numpy separados:
+
+```python
+X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
+y = pie_pumpkins['Price']
+```
+
+> Note que tivemos que realizar `reshape` nos dados de entrada para que o pacote de regressão linear os entendesse corretamente. A regressão linear espera um array 2D como entrada, onde cada linha do array corresponde a um vetor de características de entrada. No nosso caso, como temos apenas uma entrada, precisamos de um array com formato N×1, onde N é o tamanho do conjunto de dados.
+
+Depois, precisamos dividir os dados em conjuntos de treino e teste, para que possamos validar nosso modelo após o treinamento:
+
+```python
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+```
+
+Finalmente, treinar o modelo de regressão linear real leva apenas duas linhas de código. Definimos o objeto `LinearRegression` e ajustamos aos nossos dados usando o método `fit`:
+
+```python
+lin_reg = LinearRegression()
+lin_reg.fit(X_train,y_train)
+```
+
+O objeto `LinearRegression` após o ajuste (`fit`) contém todos os coeficientes da regressão, que podem ser acessados usando a propriedade `.coef_`. No nosso caso, há apenas um coeficiente, que deve ser em torno de `-0.017`. Isso significa que os preços parecem cair um pouco com o tempo, mas não muito, cerca de 2 centavos por dia. Também podemos acessar o ponto de interseção da regressão com o eixo Y usando `lin_reg.intercept_` - será em torno de `21` no nosso caso, indicando o preço no início do ano.
+
+Para ver quão preciso nosso modelo é, podemos prever preços em um conjunto de dados de teste e, em seguida, medir quão próximas nossas previsões estão dos valores esperados. Isso pode ser feito usando a métrica de erro quadrático médio (MSE), que é a média de todas as diferenças quadradas entre o valor esperado e o valor previsto.
+
+```python
+pred = lin_reg.predict(X_test)
+
+mse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
+```
+Nosso erro parece estar em torno de 2 pontos, o que equivale a ~17%. Não é muito bom. Outro indicador da qualidade do modelo é o **coeficiente de determinação**, que pode ser obtido assim:
+
+```python
+score = lin_reg.score(X_train,y_train)
+print('Model determination: ', score)
+```
+Se o valor for 0, significa que o modelo não leva os dados de entrada em consideração e age como o *pior preditor linear*, que é simplesmente o valor médio do resultado. O valor 1 significa que podemos prever perfeitamente todos os resultados esperados. No nosso caso, o coeficiente está em torno de 0,06, o que é bastante baixo.
+
+Também podemos plotar os dados de teste junto com a linha de regressão para entender melhor como a regressão funciona no nosso caso:
+
+```python
+plt.scatter(X_test,y_test)
+plt.plot(X_test,pred)
+```
+
+<img alt="Regressão linear" src="../../../../translated_images/pt-BR/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
+
+## Regressão Polinomial
+
+Outro tipo de Regressão Linear é a Regressão Polinomial. Embora às vezes haja uma relação linear entre as variáveis - quanto maior o volume da abóbora, maior o preço - às vezes essas relações não podem ser representadas como um plano ou linha reta.
+
+✅ Aqui estão [alguns exemplos](https://online.stat.psu.edu/stat501/lesson/9/9.8) de dados que poderiam usar Regressão Polinomial.
+
+Observe novamente a relação entre Data e Preço. Esse gráfico de dispersão parece que deveria ser analisado necessariamente por uma linha reta? Os preços não podem flutuar? Nesse caso, você pode tentar a regressão polinomial.
+
+✅ Polinômios são expressões matemáticas que podem consistir em uma ou mais variáveis e coeficientes.
+
+A regressão polinomial cria uma linha curva para ajustar melhor os dados não lineares. No nosso caso, se incluirmos uma variável `DayOfYear` ao quadrado nos dados de entrada, devemos ser capazes de ajustar nossos dados com uma curva parabólica, que terá um mínimo em um determinado ponto do ano.
+
+O Scikit-learn inclui uma [API de pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) útil para combinar diferentes etapas de processamento de dados. Um **pipeline** é uma cadeia de **estimadores**. No nosso caso, criaremos um pipeline que primeiro adiciona características polinomiais ao nosso modelo e, em seguida, treina a regressão:
+
+```python
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.pipeline import make_pipeline
+
+pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
+
+pipeline.fit(X_train,y_train)
+```
+
+Usar `PolynomialFeatures(2)` significa que incluiremos todos os polinômios de segundo grau dos dados de entrada. No nosso caso, isso significará apenas `DayOfYear`<sup>2</sup>, mas, dado duas variáveis de entrada X e Y, isso adicionará X<sup>2</sup>, XY e Y<sup>2</sup>. Também podemos usar polinômios de grau superior, se quisermos.
+
+Os pipelines podem ser usados da mesma maneira que o objeto original `LinearRegression`, ou seja, podemos usar `fit` no pipeline e, em seguida, usar `predict` para obter os resultados da previsão. Aqui está o gráfico mostrando os dados de teste e a curva de aproximação:
+
+<img alt="Regressão polinomial" src="../../../../translated_images/pt-BR/poly-results.ee587348f0f1f60b.webp" width="50%" />
+
+Usando Regressão Polinomial, podemos obter um MSE ligeiramente menor e um coeficiente de determinação maior, mas não significativamente. Precisamos levar em conta outras características!
+
+> Você pode ver que os preços mínimos das abóboras são observados em algum momento próximo ao Halloween. Como você explicaria isso?
+
+🎃 Parabéns, você acabou de criar um modelo que pode ajudar a prever o preço das abóboras para torta. Você provavelmente pode repetir o mesmo procedimento para todos os tipos de abóbora, mas isso seria tedioso. Vamos aprender agora como levar em conta a variedade de abóbora no nosso modelo!
+
+## Características Categóricas
+
+No mundo ideal, queremos ser capazes de prever preços para diferentes variedades de abóbora usando o mesmo modelo. No entanto, a coluna `Variety` é um pouco diferente de colunas como `Month`, porque contém valores não numéricos. Essas colunas são chamadas de **categóricas**.
+
+[![ML para iniciantes - Previsões com características categóricas usando Regressão Linear](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML para iniciantes - Previsões com características categóricas usando Regressão Linear")
+
+> 🎥 Clique na imagem acima para um breve vídeo sobre o uso de características categóricas.
+
+Aqui você pode ver como o preço médio depende da variedade:
+
+<img alt="Preço médio por variedade" src="../../../../translated_images/pt-BR/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
+
+Para levar a variedade em conta, primeiro precisamos convertê-la para forma numérica, ou **codificá-la**. Existem várias maneiras de fazer isso:
+
+* A **codificação numérica simples** criará uma tabela de diferentes variedades e, em seguida, substituirá o nome da variedade por um índice nessa tabela. Essa não é a melhor ideia para regressão linear, porque a regressão linear leva o valor numérico real do índice e o adiciona ao resultado, multiplicando por algum coeficiente. No nosso caso, a relação entre o número do índice e o preço é claramente não linear, mesmo que garantamos que os índices sejam ordenados de alguma forma específica.
+* A **codificação one-hot** substituirá a coluna `Variety` por 4 colunas diferentes, uma para cada variedade. Cada coluna conterá `1` se a linha correspondente for de uma determinada variedade e `0` caso contrário. Isso significa que haverá quatro coeficientes na regressão linear, um para cada variedade de abóbora, responsável pelo "preço inicial" (ou melhor, "preço adicional") para aquela variedade específica.
+
+O código abaixo mostra como podemos codificar uma variedade usando one-hot:
+
+```python
+pd.get_dummies(new_pumpkins['Variety'])
+```
+
+ ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
+----|-----------|-----------|--------------------------|----------
+70 | 0 | 0 | 0 | 1
+71 | 0 | 0 | 0 | 1
+... | ... | ... | ... | ...
+1738 | 0 | 1 | 0 | 0
+1739 | 0 | 1 | 0 | 0
+1740 | 0 | 1 | 0 | 0
+1741 | 0 | 1 | 0 | 0
+1742 | 0 | 1 | 0 | 0
+
+Para treinar a regressão linear usando a variedade codificada como one-hot nos dados de entrada, só precisamos inicializar os dados `X` e `y` corretamente:
+
+```python
+X = pd.get_dummies(new_pumpkins['Variety'])
+y = new_pumpkins['Price']
+```
+
+O restante do código é o mesmo que usamos acima para treinar a Regressão Linear. Se você tentar, verá que o erro médio quadrático é aproximadamente o mesmo, mas obtemos um coeficiente de determinação muito maior (~77%). Para obter previsões ainda mais precisas, podemos levar em conta mais características categóricas, bem como características numéricas, como `Month` ou `DayOfYear`. Para obter um grande array de características, podemos usar `join`:
+
+```python
+X = pd.get_dummies(new_pumpkins['Variety']) \
+        .join(new_pumpkins['Month']) \
+        .join(pd.get_dummies(new_pumpkins['City'])) \
+        .join(pd.get_dummies(new_pumpkins['Package']))
+y = new_pumpkins['Price']
+```
+
+Aqui também levamos em conta `City` e o tipo de `Package`, o que nos dá um MSE de 2.84 (10%) e um coeficiente de determinação de 0.94!
+
+## Juntando tudo
+
+Para criar o melhor modelo, podemos usar dados combinados (categóricos codificados como one-hot + numéricos) do exemplo acima junto com a Regressão Polinomial. Aqui está o código completo para sua conveniência:
+
+```python
+# set up training data
+X = pd.get_dummies(new_pumpkins['Variety']) \
+        .join(new_pumpkins['Month']) \
+        .join(pd.get_dummies(new_pumpkins['City'])) \
+        .join(pd.get_dummies(new_pumpkins['Package']))
+y = new_pumpkins['Price']
+
+# make train-test split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+
+# setup and train the pipeline
+pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
+pipeline.fit(X_train,y_train)
+
+# predict results for test data
+pred = pipeline.predict(X_test)
+
+# calculate MSE and determination
+mse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
+
+score = pipeline.score(X_train,y_train)
+print('Model determination: ', score)
+```
+
+Isso deve nos dar o melhor coeficiente de determinação de quase 97% e MSE=2.23 (~8% de erro de previsão).
+
+| Modelo | MSE | Determinação |
+|--------|-----|--------------|
+| `DayOfYear` Linear | 2.77 (17.2%) | 0.07 |
+| `DayOfYear` Polinomial | 2.73 (17.0%) | 0.08 |
+| `Variety` Linear | 5.24 (19.7%) | 0.77 |
+| Todas as características Linear | 2.84 (10.5%) | 0.94 |
+| Todas as características Polinomial | 2.23 (8.25%) | 0.97 |
+
+🏆 Muito bem! Você criou quatro modelos de Regressão em uma única lição e melhorou a qualidade do modelo para 97%. Na seção final sobre Regressão, você aprenderá sobre Regressão Logística para determinar categorias.
+
+---
+## 🚀Desafio
+
+Teste várias variáveis diferentes neste notebook para ver como a correlação corresponde à precisão do modelo.
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+## Revisão e Autoestudo
+
+Nesta lição, aprendemos sobre Regressão Linear. Existem outros tipos importantes de Regressão. Leia sobre as técnicas Stepwise, Ridge, Lasso e Elasticnet. Um bom curso para aprender mais é o [curso de Aprendizado Estatístico de Stanford](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning).
+
+## Tarefa
+
+[Construa um Modelo](assignment.md)
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/3-Linear/assignment.md

@@ -0,0 +1,16 @@
+# Criar um Modelo de Regressão
+
+## Instruções
+
+Nesta lição, você aprendeu como construir um modelo usando Regressão Linear e Polinomial. Usando esse conhecimento, encontre um conjunto de dados ou utilize um dos conjuntos integrados do Scikit-learn para criar um novo modelo. Explique em seu notebook por que escolheu a técnica utilizada e demonstre a precisão do seu modelo. Se ele não for preciso, explique o motivo.
+
+## Rubrica
+
+| Critério | Exemplary                                                    | Adequate                   | Needs Improvement               |
+| -------- | ------------------------------------------------------------ | -------------------------- | ------------------------------- |
+|          | apresenta um notebook completo com uma solução bem documentada | a solução está incompleta  | a solução apresenta falhas ou bugs |
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/3-Linear/notebook.ipynb

@@ -0,0 +1,128 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preços de Abóboras\n",
+    "\n",
+    "Carregue as bibliotecas necessárias e o conjunto de dados. Converta os dados em um dataframe contendo um subconjunto dos dados:\n",
+    "\n",
+    "- Considere apenas abóboras com preços por alqueire\n",
+    "- Converta a data para o formato de mês\n",
+    "- Calcule o preço como a média entre os preços mais altos e mais baixos\n",
+    "- Converta o preço para refletir a precificação pela quantidade em alqueires\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from datetime import datetime\n",
+    "\n",
+    "pumpkins = pd.read_csv('../data/US-pumpkins.csv')\n",
+    "\n",
+    "pumpkins.head()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]\n",
+    "\n",
+    "columns_to_select = ['Package', 'Variety', 'City Name', 'Low Price', 'High Price', 'Date']\n",
+    "pumpkins = pumpkins.loc[:, columns_to_select]\n",
+    "\n",
+    "price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2\n",
+    "\n",
+    "month = pd.DatetimeIndex(pumpkins['Date']).month\n",
+    "day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)\n",
+    "\n",
+    "new_pumpkins = pd.DataFrame(\n",
+    "    {'Month': month, \n",
+    "     'DayOfYear' : day_of_year, \n",
+    "     'Variety': pumpkins['Variety'], \n",
+    "     'City': pumpkins['City Name'], \n",
+    "     'Package': pumpkins['Package'], \n",
+    "     'Low Price': pumpkins['Low Price'],\n",
+    "     'High Price': pumpkins['High Price'], \n",
+    "     'Price': price})\n",
+    "\n",
+    "new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/1.1\n",
+    "new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price*2\n",
+    "\n",
+    "new_pumpkins.head()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Um gráfico de dispersão básico nos lembra que temos dados mensais apenas de agosto a dezembro. Provavelmente precisamos de mais dados para poder tirar conclusões de forma linear.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "plt.scatter('Month','Price',data=new_pumpkins)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "plt.scatter('DayOfYear','Price',data=new_pumpkins)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n---\n\n**Aviso Legal**:  \nEste documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.3-final"
+  },
+  "orig_nbformat": 2,
+  "coopTranslator": {
+   "original_hash": "b032d371c75279373507f003439a577e",
+   "translation_date": "2025-08-29T22:45:29+00:00",
+   "source_file": "2-Regression/3-Linear/notebook.ipynb",
+   "language_code": "br"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

translations/pt-BR/2-Regression/3-Linear/solution/Julia/README.md

@@ -0,0 +1,6 @@
+
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/4-Logistic/README.md

@@ -0,0 +1,405 @@
+# Regressão logística para prever categorias
+
+![Infográfico de regressão logística vs. regressão linear](../../../../2-Regression/4-Logistic/images/linear-vs-logistic.png)
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+> ### [Esta aula está disponível em R!](../../../../2-Regression/4-Logistic/solution/R/lesson_4.html)
+
+## Introdução
+
+Nesta última aula sobre Regressão, uma das técnicas básicas _clássicas_ de ML, vamos explorar a Regressão Logística. Você usaria essa técnica para descobrir padrões e prever categorias binárias. Este doce é chocolate ou não? Esta doença é contagiosa ou não? Este cliente escolherá este produto ou não?
+
+Nesta aula, você aprenderá:
+
+- Uma nova biblioteca para visualização de dados
+- Técnicas de regressão logística
+
+✅ Aprofunde seu entendimento sobre como trabalhar com este tipo de regressão neste [módulo de aprendizado](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-77952-leestott)
+
+## Pré-requisito
+
+Depois de trabalhar com os dados de abóbora, já estamos suficientemente familiarizados para perceber que há uma categoria binária com a qual podemos trabalhar: `Color`.
+
+Vamos construir um modelo de regressão logística para prever, com base em algumas variáveis, _qual é a cor provável de uma determinada abóbora_ (laranja 🎃 ou branca 👻).
+
+> Por que estamos falando de classificação binária em uma aula sobre regressão? Apenas por conveniência linguística, já que a regressão logística é [na verdade um método de classificação](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), embora baseado em linearidade. Aprenda sobre outras formas de classificar dados no próximo grupo de aulas.
+
+## Definir a pergunta
+
+Para nossos propósitos, vamos expressar isso como um binário: 'Branca' ou 'Não Branca'. Há também uma categoria 'listrada' em nosso conjunto de dados, mas há poucas instâncias dela, então não a utilizaremos. Ela desaparece quando removemos valores nulos do conjunto de dados, de qualquer forma.
+
+> 🎃 Curiosidade: às vezes chamamos abóboras brancas de abóboras 'fantasma'. Elas não são muito fáceis de esculpir, então não são tão populares quanto as laranjas, mas têm uma aparência interessante! Assim, poderíamos reformular nossa pergunta como: 'Fantasma' ou 'Não Fantasma'. 👻
+
+## Sobre regressão logística
+
+A regressão logística difere da regressão linear, que você aprendeu anteriormente, em alguns aspectos importantes.
+
+[![ML para iniciantes - Entendendo a Regressão Logística para Classificação de Machine Learning](https://img.youtube.com/vi/KpeCT6nEpBY/0.jpg)](https://youtu.be/KpeCT6nEpBY "ML para iniciantes - Entendendo a Regressão Logística para Classificação de Machine Learning")
+
+> 🎥 Clique na imagem acima para um breve vídeo sobre regressão logística.
+
+### Classificação binária
+
+A regressão logística não oferece os mesmos recursos que a regressão linear. A primeira oferece uma previsão sobre uma categoria binária ("branca ou não branca"), enquanto a segunda é capaz de prever valores contínuos, por exemplo, dado a origem de uma abóbora e o tempo de colheita, _quanto seu preço aumentará_.
+
+![Modelo de classificação de abóbora](../../../../2-Regression/4-Logistic/images/pumpkin-classifier.png)
+> Infográfico por [Dasani Madipalli](https://twitter.com/dasani_decoded)
+
+### Outras classificações
+
+Existem outros tipos de regressão logística, incluindo multinomial e ordinal:
+
+- **Multinomial**, que envolve mais de uma categoria - "Laranja, Branca e Listrada".
+- **Ordinal**, que envolve categorias ordenadas, útil se quisermos ordenar nossos resultados logicamente, como nossas abóboras que são ordenadas por um número finito de tamanhos (mini, pequeno, médio, grande, extra grande, extra extra grande).
+
+![Regressão multinomial vs ordinal](../../../../2-Regression/4-Logistic/images/multinomial-vs-ordinal.png)
+
+### As variáveis NÃO precisam ser correlacionadas
+
+Lembra como a regressão linear funcionava melhor com variáveis mais correlacionadas? A regressão logística é o oposto - as variáveis não precisam estar alinhadas. Isso funciona para este conjunto de dados, que tem correlações relativamente fracas.
+
+### Você precisa de muitos dados limpos
+
+A regressão logística fornecerá resultados mais precisos se você usar mais dados; nosso pequeno conjunto de dados não é ideal para esta tarefa, então tenha isso em mente.
+
+[![ML para iniciantes - Análise e Preparação de Dados para Regressão Logística](https://img.youtube.com/vi/B2X4H9vcXTs/0.jpg)](https://youtu.be/B2X4H9vcXTs "ML para iniciantes - Análise e Preparação de Dados para Regressão Logística")
+
+> 🎥 Clique na imagem acima para um breve vídeo sobre preparação de dados para regressão linear.
+
+✅ Pense nos tipos de dados que se adaptariam bem à regressão logística.
+
+## Exercício - organizar os dados
+
+Primeiro, limpe os dados, removendo valores nulos e selecionando apenas algumas colunas:
+
+1. Adicione o seguinte código:
+
+    ```python
+  
+    columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
+    pumpkins = full_pumpkins.loc[:, columns_to_select]
+
+    pumpkins.dropna(inplace=True)
+    ```
+
+    Você sempre pode dar uma olhada no seu novo dataframe:
+
+    ```python
+    pumpkins.info
+    ```
+
+### Visualização - gráfico categórico
+
+Agora você carregou o [notebook inicial](../../../../2-Regression/4-Logistic/notebook.ipynb) com os dados de abóbora novamente e os limpou para preservar um conjunto de dados contendo algumas variáveis, incluindo `Color`. Vamos visualizar o dataframe no notebook usando uma biblioteca diferente: [Seaborn](https://seaborn.pydata.org/index.html), que é construída sobre o Matplotlib que usamos anteriormente.
+
+Seaborn oferece algumas maneiras interessantes de visualizar seus dados. Por exemplo, você pode comparar distribuições dos dados para cada `Variety` e `Color` em um gráfico categórico.
+
+1. Crie tal gráfico usando a função `catplot`, com os dados de abóbora `pumpkins`, e especificando um mapeamento de cores para cada categoria de abóbora (laranja ou branca):
+
+    ```python
+    import seaborn as sns
+    
+    palette = {
+    'ORANGE': 'orange',
+    'WHITE': 'wheat',
+    }
+
+    sns.catplot(
+    data=pumpkins, y="Variety", hue="Color", kind="count",
+    palette=palette, 
+    )
+    ```
+
+    ![Uma grade de dados visualizados](../../../../2-Regression/4-Logistic/images/pumpkins_catplot_1.png)
+
+    Observando os dados, você pode ver como os dados de `Color` se relacionam com `Variety`.
+
+    ✅ Dado este gráfico categórico, quais são algumas explorações interessantes que você pode imaginar?
+
+### Pré-processamento de dados: codificação de características e rótulos
+
+Nosso conjunto de dados de abóboras contém valores de string para todas as suas colunas. Trabalhar com dados categóricos é intuitivo para humanos, mas não para máquinas. Algoritmos de aprendizado de máquina funcionam bem com números. É por isso que a codificação é uma etapa muito importante na fase de pré-processamento de dados, pois nos permite transformar dados categóricos em dados numéricos, sem perder nenhuma informação. Uma boa codificação leva à construção de um bom modelo.
+
+Para codificação de características, existem dois tipos principais de codificadores:
+
+1. Codificador ordinal: é adequado para variáveis ordinais, que são variáveis categóricas cujos dados seguem uma ordem lógica, como a coluna `Item Size` em nosso conjunto de dados. Ele cria um mapeamento de forma que cada categoria seja representada por um número, que é a ordem da categoria na coluna.
+
+    ```python
+    from sklearn.preprocessing import OrdinalEncoder
+
+    item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
+    ordinal_features = ['Item Size']
+    ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
+    ```
+
+2. Codificador categórico: é adequado para variáveis nominais, que são variáveis categóricas cujos dados não seguem uma ordem lógica, como todas as características diferentes de `Item Size` em nosso conjunto de dados. É uma codificação one-hot, o que significa que cada categoria é representada por uma coluna binária: a variável codificada é igual a 1 se a abóbora pertence àquela `Variety` e 0 caso contrário.
+
+    ```python
+    from sklearn.preprocessing import OneHotEncoder
+
+    categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
+    categorical_encoder = OneHotEncoder(sparse_output=False)
+    ```
+
+Então, `ColumnTransformer` é usado para combinar múltiplos codificadores em uma única etapa e aplicá-los às colunas apropriadas.
+
+```python
+    from sklearn.compose import ColumnTransformer
+    
+    ct = ColumnTransformer(transformers=[
+        ('ord', ordinal_encoder, ordinal_features),
+        ('cat', categorical_encoder, categorical_features)
+        ])
+    
+    ct.set_output(transform='pandas')
+    encoded_features = ct.fit_transform(pumpkins)
+```
+
+Por outro lado, para codificar o rótulo, usamos a classe `LabelEncoder` do scikit-learn, que é uma classe utilitária para ajudar a normalizar rótulos de forma que contenham apenas valores entre 0 e n_classes-1 (aqui, 0 e 1).
+
+```python
+    from sklearn.preprocessing import LabelEncoder
+
+    label_encoder = LabelEncoder()
+    encoded_label = label_encoder.fit_transform(pumpkins['Color'])
+```
+
+Depois de codificar as características e o rótulo, podemos mesclá-los em um novo dataframe `encoded_pumpkins`.
+
+```python
+    encoded_pumpkins = encoded_features.assign(Color=encoded_label)
+```
+
+✅ Quais são as vantagens de usar um codificador ordinal para a coluna `Item Size`?
+
+### Analisar relações entre variáveis
+
+Agora que pré-processamos nossos dados, podemos analisar as relações entre as características e o rótulo para ter uma ideia de quão bem o modelo será capaz de prever o rótulo com base nas características. 
+
+A melhor maneira de realizar esse tipo de análise é plotando os dados. Usaremos novamente a função `catplot` do Seaborn para visualizar as relações entre `Item Size`, `Variety` e `Color` em um gráfico categórico. Para melhor plotar os dados, usaremos a coluna codificada `Item Size` e a coluna não codificada `Variety`.
+
+```python
+    palette = {
+    'ORANGE': 'orange',
+    'WHITE': 'wheat',
+    }
+    pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']
+
+    g = sns.catplot(
+        data=pumpkins,
+        x="Item Size", y="Color", row='Variety',
+        kind="box", orient="h",
+        sharex=False, margin_titles=True,
+        height=1.8, aspect=4, palette=palette,
+    )
+    g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
+    g.set_titles(row_template="{row_name}")
+```
+
+![Um gráfico categórico de dados visualizados](../../../../2-Regression/4-Logistic/images/pumpkins_catplot_2.png)
+
+### Usar um gráfico de dispersão
+
+Como `Color` é uma categoria binária (Branca ou Não), ela precisa de '[uma abordagem especializada](https://seaborn.pydata.org/tutorial/categorical.html?highlight=bar) para visualização'. Existem outras maneiras de visualizar a relação dessa categoria com outras variáveis.
+
+Você pode visualizar variáveis lado a lado com gráficos do Seaborn.
+
+1. Experimente um gráfico de dispersão ('swarm plot') para mostrar a distribuição de valores:
+
+    ```python
+    palette = {
+    0: 'orange',
+    1: 'wheat'
+    }
+    sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
+    ```
+
+    ![Um gráfico de dispersão de dados visualizados](../../../../2-Regression/4-Logistic/images/swarm_2.png)
+
+**Atenção**: o código acima pode gerar um aviso, já que o Seaborn pode falhar ao representar uma quantidade tão grande de pontos de dados em um gráfico de dispersão. Uma solução possível é diminuir o tamanho do marcador, usando o parâmetro 'size'. No entanto, esteja ciente de que isso afeta a legibilidade do gráfico.
+
+> **🧮 Mostre-me a Matemática**
+>
+> A regressão logística se baseia no conceito de 'máxima verossimilhança' usando [funções sigmoides](https://wikipedia.org/wiki/Sigmoid_function). Uma 'Função Sigmoide' em um gráfico tem a forma de um 'S'. Ela pega um valor e o mapeia para algo entre 0 e 1. Sua curva também é chamada de 'curva logística'. Sua fórmula é assim:
+>
+> ![função logística](../../../../2-Regression/4-Logistic/images/sigmoid.png)
+>
+> onde o ponto médio da sigmoide encontra-se no ponto 0 de x, L é o valor máximo da curva, e k é a inclinação da curva. Se o resultado da função for maior que 0.5, o rótulo em questão será atribuído à classe '1' da escolha binária. Caso contrário, será classificado como '0'.
+
+## Construir seu modelo
+
+Construir um modelo para encontrar essas classificações binárias é surpreendentemente simples no Scikit-learn.
+
+[![ML para iniciantes - Regressão Logística para classificação de dados](https://img.youtube.com/vi/MmZS2otPrQ8/0.jpg)](https://youtu.be/MmZS2otPrQ8 "ML para iniciantes - Regressão Logística para classificação de dados")
+
+> 🎥 Clique na imagem acima para um breve vídeo sobre construção de um modelo de regressão linear.
+
+1. Selecione as variáveis que deseja usar em seu modelo de classificação e divida os conjuntos de treinamento e teste chamando `train_test_split()`:
+
+    ```python
+    from sklearn.model_selection import train_test_split
+    
+    X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
+    y = encoded_pumpkins['Color']
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+    
+    ```
+
+2. Agora você pode treinar seu modelo, chamando `fit()` com seus dados de treinamento, e imprimir o resultado:
+
+    ```python
+    from sklearn.metrics import f1_score, classification_report 
+    from sklearn.linear_model import LogisticRegression
+
+    model = LogisticRegression()
+    model.fit(X_train, y_train)
+    predictions = model.predict(X_test)
+
+    print(classification_report(y_test, predictions))
+    print('Predicted labels: ', predictions)
+    print('F1-score: ', f1_score(y_test, predictions))
+    ```
+
+    Veja o desempenho do seu modelo. Não está ruim, considerando que você tem apenas cerca de 1000 linhas de dados:
+
+    ```output
+                       precision    recall  f1-score   support
+    
+                    0       0.94      0.98      0.96       166
+                    1       0.85      0.67      0.75        33
+    
+        accuracy                                0.92       199
+        macro avg           0.89      0.82      0.85       199
+        weighted avg        0.92      0.92      0.92       199
+    
+        Predicted labels:  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0
+        0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+        1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0
+        0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
+        0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
+        0 0 0 1 0 0 0 0 0 0 0 0 1 1]
+        F1-score:  0.7457627118644068
+    ```
+
+## Melhor compreensão via uma matriz de confusão
+
+Embora você possa obter um relatório de desempenho [termos](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html?highlight=classification_report#sklearn.metrics.classification_report) imprimindo os itens acima, talvez consiga entender seu modelo mais facilmente usando uma [matriz de confusão](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) para ajudar a entender como o modelo está se saindo.
+
+> 🎓 Uma '[matriz de confusão](https://wikipedia.org/wiki/Confusion_matrix)' (ou 'matriz de erro') é uma tabela que expressa os verdadeiros vs. falsos positivos e negativos do seu modelo, avaliando assim a precisão das previsões.
+
+1. Para usar uma matriz de confusão, chame `confusion_matrix()`:
+
+    ```python
+    from sklearn.metrics import confusion_matrix
+    confusion_matrix(y_test, predictions)
+    ```
+
+    Veja a matriz de confusão do seu modelo:
+
+    ```output
+    array([[162,   4],
+           [ 11,  22]])
+    ```
+
+No Scikit-learn, as linhas (eixo 0) são os rótulos reais e as colunas (eixo 1) são os rótulos previstos.
+
+|       |   0   |   1   |
+| :---: | :---: | :---: |
+|   0   |  TN   |  FP   |
+|   1   |  FN   |  TP   |
+
+O que está acontecendo aqui? Digamos que nosso modelo seja solicitado a classificar abóboras entre duas categorias binárias, categoria 'branca' e categoria 'não branca'.
+
+- Se seu modelo prevê uma abóbora como não branca e ela pertence à categoria 'não branca' na realidade, chamamos isso de verdadeiro negativo, mostrado pelo número no canto superior esquerdo.
+- Se seu modelo prevê uma abóbora como branca e ela pertence à categoria 'não branca' na realidade, chamamos isso de falso negativo, mostrado pelo número no canto inferior esquerdo.
+- Se seu modelo prevê uma abóbora como não branca e ela pertence à categoria 'branca' na realidade, chamamos isso de falso positivo, mostrado pelo número no canto superior direito.
+- Se seu modelo prevê uma abóbora como branca e ela pertence à categoria 'branca' na realidade, chamamos isso de verdadeiro positivo, mostrado pelo número no canto inferior direito.
+
+Como você deve ter imaginado, é preferível ter um número maior de verdadeiros positivos e verdadeiros negativos e um número menor de falsos positivos e falsos negativos, o que implica que o modelo está se saindo melhor.
+Como a matriz de confusão se relaciona com precisão e recall? Lembre-se, o relatório de classificação mostrado acima indicou precisão (0,85) e recall (0,67).
+
+Precisão = tp / (tp + fp) = 22 / (22 + 4) = 0,8461538461538461
+
+Recall = tp / (tp + fn) = 22 / (22 + 11) = 0,6666666666666666
+
+✅ P: De acordo com a matriz de confusão, como o modelo se saiu? R: Não foi ruim; há um bom número de verdadeiros negativos, mas também alguns falsos negativos.
+
+Vamos revisitar os termos que vimos anteriormente com a ajuda do mapeamento de TP/TN e FP/FN na matriz de confusão:
+
+🎓 Precisão: TP/(TP + FP) A fração de instâncias relevantes entre as instâncias recuperadas (ex.: quais rótulos foram bem rotulados)
+
+🎓 Recall: TP/(TP + FN) A fração de instâncias relevantes que foram recuperadas, independentemente de estarem bem rotuladas ou não
+
+🎓 f1-score: (2 * precisão * recall)/(precisão + recall) Uma média ponderada entre precisão e recall, sendo o melhor 1 e o pior 0
+
+🎓 Suporte: O número de ocorrências de cada rótulo recuperado
+
+🎓 Precisão geral: (TP + TN)/(TP + TN + FP + FN) A porcentagem de rótulos previstos corretamente para uma amostra.
+
+🎓 Média Macro: O cálculo das métricas médias não ponderadas para cada rótulo, sem levar em conta o desequilíbrio entre os rótulos.
+
+🎓 Média Ponderada: O cálculo das métricas médias para cada rótulo, levando em conta o desequilíbrio entre os rótulos ao ponderá-los pelo suporte (o número de instâncias verdadeiras para cada rótulo).
+
+✅ Você consegue pensar em qual métrica deve observar se quiser que seu modelo reduza o número de falsos negativos?
+
+## Visualizar a curva ROC deste modelo
+
+[![ML para iniciantes - Analisando o desempenho da regressão logística com curvas ROC](https://img.youtube.com/vi/GApO575jTA0/0.jpg)](https://youtu.be/GApO575jTA0 "ML para iniciantes - Analisando o desempenho da regressão logística com curvas ROC")
+
+> 🎥 Clique na imagem acima para um breve vídeo sobre curvas ROC
+
+Vamos fazer mais uma visualização para ver a chamada curva 'ROC':
+
+```python
+from sklearn.metrics import roc_curve, roc_auc_score
+import matplotlib
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+y_scores = model.predict_proba(X_test)
+fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
+
+fig = plt.figure(figsize=(6, 6))
+plt.plot([0, 1], [0, 1], 'k--')
+plt.plot(fpr, tpr)
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('ROC Curve')
+plt.show()
+```
+
+Usando Matplotlib, plote a [Curva Característica de Operação do Receptor](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) ou ROC do modelo. As curvas ROC são frequentemente usadas para visualizar o desempenho de um classificador em termos de seus verdadeiros positivos versus falsos positivos. "As curvas ROC geralmente apresentam a taxa de verdadeiros positivos no eixo Y e a taxa de falsos positivos no eixo X." Assim, a inclinação da curva e o espaço entre a linha do ponto médio e a curva são importantes: você quer uma curva que rapidamente suba e ultrapasse a linha. No nosso caso, há falsos positivos no início, e então a linha sobe e ultrapassa adequadamente:
+
+![ROC](../../../../2-Regression/4-Logistic/images/ROC_2.png)
+
+Por fim, use a API [`roc_auc_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) do Scikit-learn para calcular a 'Área Sob a Curva' (AUC):
+
+```python
+auc = roc_auc_score(y_test,y_scores[:,1])
+print(auc)
+```
+O resultado é `0.9749908725812341`. Dado que o AUC varia de 0 a 1, você quer um valor alto, já que um modelo que é 100% correto em suas previsões terá um AUC de 1; neste caso, o modelo está _muito bom_.
+
+Em futuras lições sobre classificações, você aprenderá como iterar para melhorar os resultados do seu modelo. Mas, por enquanto, parabéns! Você concluiu estas lições sobre regressão!
+
+---
+## 🚀Desafio
+
+Há muito mais para explorar sobre regressão logística! Mas a melhor maneira de aprender é experimentando. Encontre um conjunto de dados que se preste a este tipo de análise e construa um modelo com ele. O que você aprende? dica: experimente [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) para conjuntos de dados interessantes.
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+## Revisão & Autoestudo
+
+Leia as primeiras páginas [deste artigo de Stanford](https://web.stanford.edu/~jurafsky/slp3/5.pdf) sobre alguns usos práticos da regressão logística. Pense em tarefas que são mais adequadas para um ou outro tipo de regressão entre as que estudamos até agora. O que funcionaria melhor?
+
+## Tarefa 
+
+[Repetindo esta regressão](assignment.md)
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/4-Logistic/assignment.md

@@ -0,0 +1,16 @@
+# Repetindo uma Regressão
+
+## Instruções
+
+Na aula, você utilizou um subconjunto dos dados de abóbora. Agora, volte aos dados originais e tente usar todos eles, limpos e padronizados, para construir um modelo de Regressão Logística.
+
+## Rubrica
+
+| Critério  | Exemplary                                                               | Adequado                                                     | Precisa de Melhorias                                        |
+| --------- | ----------------------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------------------- |
+|           | Um notebook é apresentado com um modelo bem explicado e de bom desempenho | Um notebook é apresentado com um modelo que apresenta desempenho mínimo | Um notebook é apresentado com um modelo de baixo desempenho ou nenhum |
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/4-Logistic/notebook.ipynb

@@ -0,0 +1,269 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Variedades de Abóbora e Cor\n",
+    "\n",
+    "Carregue as bibliotecas necessárias e o conjunto de dados. Converta os dados para um dataframe contendo um subconjunto dos dados:\n",
+    "\n",
+    "Vamos observar a relação entre cor e variedade\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>City Name</th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Package</th>\n",
+       "      <th>Variety</th>\n",
+       "      <th>Sub Variety</th>\n",
+       "      <th>Grade</th>\n",
+       "      <th>Date</th>\n",
+       "      <th>Low Price</th>\n",
+       "      <th>High Price</th>\n",
+       "      <th>Mostly Low</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Unit of Sale</th>\n",
+       "      <th>Quality</th>\n",
+       "      <th>Condition</th>\n",
+       "      <th>Appearance</th>\n",
+       "      <th>Storage</th>\n",
+       "      <th>Crop</th>\n",
+       "      <th>Repack</th>\n",
+       "      <th>Trans Mode</th>\n",
+       "      <th>Unnamed: 24</th>\n",
+       "      <th>Unnamed: 25</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>BALTIMORE</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>24 inch bins</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>4/29/17</td>\n",
+       "      <td>270.0</td>\n",
+       "      <td>280.0</td>\n",
+       "      <td>270.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>E</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>BALTIMORE</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>24 inch bins</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>5/6/17</td>\n",
+       "      <td>270.0</td>\n",
+       "      <td>280.0</td>\n",
+       "      <td>270.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>E</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>BALTIMORE</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>24 inch bins</td>\n",
+       "      <td>HOWDEN TYPE</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>9/24/16</td>\n",
+       "      <td>160.0</td>\n",
+       "      <td>160.0</td>\n",
+       "      <td>160.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>N</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>BALTIMORE</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>24 inch bins</td>\n",
+       "      <td>HOWDEN TYPE</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>9/24/16</td>\n",
+       "      <td>160.0</td>\n",
+       "      <td>160.0</td>\n",
+       "      <td>160.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>N</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>BALTIMORE</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>24 inch bins</td>\n",
+       "      <td>HOWDEN TYPE</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>11/5/16</td>\n",
+       "      <td>90.0</td>\n",
+       "      <td>100.0</td>\n",
+       "      <td>90.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>N</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 26 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   City Name Type       Package      Variety Sub Variety  Grade     Date  \\\n",
+       "0  BALTIMORE  NaN  24 inch bins          NaN         NaN    NaN  4/29/17   \n",
+       "1  BALTIMORE  NaN  24 inch bins          NaN         NaN    NaN   5/6/17   \n",
+       "2  BALTIMORE  NaN  24 inch bins  HOWDEN TYPE         NaN    NaN  9/24/16   \n",
+       "3  BALTIMORE  NaN  24 inch bins  HOWDEN TYPE         NaN    NaN  9/24/16   \n",
+       "4  BALTIMORE  NaN  24 inch bins  HOWDEN TYPE         NaN    NaN  11/5/16   \n",
+       "\n",
+       "   Low Price  High Price  Mostly Low  ...  Unit of Sale Quality Condition  \\\n",
+       "0      270.0       280.0       270.0  ...           NaN     NaN       NaN   \n",
+       "1      270.0       280.0       270.0  ...           NaN     NaN       NaN   \n",
+       "2      160.0       160.0       160.0  ...           NaN     NaN       NaN   \n",
+       "3      160.0       160.0       160.0  ...           NaN     NaN       NaN   \n",
+       "4       90.0       100.0        90.0  ...           NaN     NaN       NaN   \n",
+       "\n",
+       "  Appearance Storage  Crop Repack  Trans Mode  Unnamed: 24  Unnamed: 25  \n",
+       "0        NaN     NaN   NaN      E         NaN          NaN          NaN  \n",
+       "1        NaN     NaN   NaN      E         NaN          NaN          NaN  \n",
+       "2        NaN     NaN   NaN      N         NaN          NaN          NaN  \n",
+       "3        NaN     NaN   NaN      N         NaN          NaN          NaN  \n",
+       "4        NaN     NaN   NaN      N         NaN          NaN          NaN  \n",
+       "\n",
+       "[5 rows x 26 columns]"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "full_pumpkins = pd.read_csv('../data/US-pumpkins.csv')\n",
+    "\n",
+    "full_pumpkins.head()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n---\n\n**Aviso Legal**:  \nEste documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.1"
+  },
+  "metadata": {
+   "interpreter": {
+    "hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
+   }
+  },
+  "orig_nbformat": 2,
+  "coopTranslator": {
+   "original_hash": "dee08c2b49057b0de8b6752c4dbca368",
+   "translation_date": "2025-08-29T22:57:44+00:00",
+   "source_file": "2-Regression/4-Logistic/notebook.ipynb",
+   "language_code": "br"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

translations/pt-BR/2-Regression/4-Logistic/solution/Julia/README.md

@@ -0,0 +1,6 @@
+
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb

@@ -0,0 +1,685 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Construir um modelo de regressão logística - Aula 4\n",
+    "\n",
+    "![Infográfico de regressão logística vs. regressão linear](../../../../../../translated_images/pt-BR/linear-vs-logistic.ba180bf95e7ee667.webp)\n",
+    "\n",
+    "#### **[Questionário pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/15/)**\n",
+    "\n",
+    "#### Introdução\n",
+    "\n",
+    "Nesta última aula sobre Regressão, uma das técnicas *clássicas* básicas de Machine Learning, vamos explorar a Regressão Logística. Você usaria essa técnica para descobrir padrões e prever categorias binárias. Este doce é de chocolate ou não? Esta doença é contagiosa ou não? Este cliente escolherá este produto ou não?\n",
+    "\n",
+    "Nesta aula, você aprenderá:\n",
+    "\n",
+    "- Técnicas para regressão logística\n",
+    "\n",
+    "✅ Aprofunde seu entendimento sobre como trabalhar com este tipo de regressão neste [módulo do Learn](https://learn.microsoft.com/training/modules/introduction-classification-models/?WT.mc_id=academic-77952-leestott)\n",
+    "\n",
+    "## Pré-requisito\n",
+    "\n",
+    "Depois de trabalhar com os dados de abóboras, já estamos suficientemente familiarizados com eles para perceber que há uma categoria binária com a qual podemos trabalhar: `Color`.\n",
+    "\n",
+    "Vamos construir um modelo de regressão logística para prever, dado algumas variáveis, *qual é a cor provável de uma determinada abóbora* (laranja 🎃 ou branca 👻).\n",
+    "\n",
+    "> Por que estamos falando de classificação binária em uma aula sobre regressão? Apenas por conveniência linguística, já que a regressão logística é [na verdade um método de classificação](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), embora baseado em um modelo linear. Aprenda sobre outras formas de classificar dados no próximo grupo de aulas.\n",
+    "\n",
+    "Para esta aula, precisaremos dos seguintes pacotes:\n",
+    "\n",
+    "- `tidyverse`: O [tidyverse](https://www.tidyverse.org/) é uma [coleção de pacotes R](https://www.tidyverse.org/packages) projetada para tornar a ciência de dados mais rápida, fácil e divertida!\n",
+    "\n",
+    "- `tidymodels`: O [tidymodels](https://www.tidymodels.org/) é uma [coleção de pacotes](https://www.tidymodels.org/packages/) para modelagem e aprendizado de máquina.\n",
+    "\n",
+    "- `janitor`: O pacote [janitor](https://github.com/sfirke/janitor) oferece ferramentas simples para examinar e limpar dados desorganizados.\n",
+    "\n",
+    "- `ggbeeswarm`: O pacote [ggbeeswarm](https://github.com/eclarke/ggbeeswarm) fornece métodos para criar gráficos no estilo \"beeswarm\" usando ggplot2.\n",
+    "\n",
+    "Você pode instalá-los com o seguinte comando:\n",
+    "\n",
+    "`install.packages(c(\"tidyverse\", \"tidymodels\", \"janitor\", \"ggbeeswarm\"))`\n",
+    "\n",
+    "Alternativamente, o script abaixo verifica se você possui os pacotes necessários para completar este módulo e os instala caso estejam ausentes.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "suppressWarnings(if (!require(\"pacman\"))install.packages(\"pacman\"))\n",
+    "\n",
+    "pacman::p_load(tidyverse, tidymodels, janitor, ggbeeswarm)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## **Defina a pergunta**\n",
+    "\n",
+    "Para os nossos propósitos, vamos expressar isso como um binário: 'Branco' ou 'Não Branco'. Há também uma categoria 'listrado' em nosso conjunto de dados, mas há poucos exemplos dela, então não a utilizaremos. De qualquer forma, ela desaparece quando removemos os valores nulos do conjunto de dados.\n",
+    "\n",
+    "> 🎃 Curiosidade: às vezes chamamos abóboras brancas de abóboras 'fantasmas'. Elas não são muito fáceis de esculpir, então não são tão populares quanto as laranjas, mas têm uma aparência bem legal! Assim, também poderíamos reformular nossa pergunta como: 'Fantasma' ou 'Não Fantasma'. 👻\n",
+    "\n",
+    "## **Sobre regressão logística**\n",
+    "\n",
+    "A regressão logística difere da regressão linear, que você aprendeu anteriormente, de algumas maneiras importantes.\n",
+    "\n",
+    "#### **Classificação binária**\n",
+    "\n",
+    "A regressão logística não oferece os mesmos recursos que a regressão linear. A primeira fornece uma previsão sobre uma `categoria binária` (\"laranja ou não laranja\"), enquanto a segunda é capaz de prever `valores contínuos`, por exemplo, dado a origem de uma abóbora e o momento da colheita, *quanto o preço dela vai aumentar*.\n",
+    "\n",
+    "![Infográfico por Dasani Madipalli](../../../../../../translated_images/pt-BR/pumpkin-classifier.562771f104ad5436.webp)\n",
+    "\n",
+    "### Outras classificações\n",
+    "\n",
+    "Existem outros tipos de regressão logística, incluindo multinomial e ordinal:\n",
+    "\n",
+    "- **Multinomial**, que envolve mais de uma categoria - \"Laranja, Branco e Listrado\".\n",
+    "\n",
+    "- **Ordinal**, que envolve categorias ordenadas, útil se quisermos organizar nossos resultados de forma lógica, como nossas abóboras ordenadas por um número finito de tamanhos (mini,pequeno,médio,grande,xl,xxl).\n",
+    "\n",
+    "![Regressão multinomial vs ordinal](../../../../../../translated_images/pt-BR/multinomial-vs-ordinal.36701b4850e37d86.webp)\n",
+    "\n",
+    "#### **As variáveis NÃO precisam ser correlacionadas**\n",
+    "\n",
+    "Lembra como a regressão linear funcionava melhor com variáveis mais correlacionadas? A regressão logística é o oposto - as variáveis não precisam estar alinhadas. Isso funciona para este conjunto de dados, que tem correlações um tanto fracas.\n",
+    "\n",
+    "#### **Você precisa de muitos dados limpos**\n",
+    "\n",
+    "A regressão logística fornecerá resultados mais precisos se você usar mais dados; nosso pequeno conjunto de dados não é o ideal para essa tarefa, então tenha isso em mente.\n",
+    "\n",
+    "✅ Pense nos tipos de dados que se adaptariam bem à regressão logística.\n",
+    "\n",
+    "## Exercício - organize os dados\n",
+    "\n",
+    "Primeiro, limpe um pouco os dados, removendo valores nulos e selecionando apenas algumas das colunas:\n",
+    "\n",
+    "1. Adicione o seguinte código:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Load the core tidyverse packages\n",
+    "library(tidyverse)\n",
+    "\n",
+    "# Import the data and clean column names\n",
+    "pumpkins <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/2-Regression/data/US-pumpkins.csv\") %>% \n",
+    "  clean_names()\n",
+    "\n",
+    "# Select desired columns\n",
+    "pumpkins_select <- pumpkins %>% \n",
+    "  select(c(city_name, package, variety, origin, item_size, color)) \n",
+    "\n",
+    "# Drop rows containing missing values and encode color as factor (category)\n",
+    "pumpkins_select <- pumpkins_select %>% \n",
+    "  drop_na() %>% \n",
+    "  mutate(color = factor(color))\n",
+    "\n",
+    "# View the first few rows\n",
+    "pumpkins_select %>% \n",
+    "  slice_head(n = 5)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Você pode sempre dar uma olhada no seu novo dataframe usando a função [*glimpse()*](https://pillar.r-lib.org/reference/glimpse.html) como mostrado abaixo:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "pumpkins_select %>% \n",
+    "  glimpse()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vamos confirmar que estaremos realmente lidando com um problema de classificação binária:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Subset distinct observations in outcome column\n",
+    "pumpkins_select %>% \n",
+    "  distinct(color)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Visualização - gráfico categórico\n",
+    "Agora você já carregou novamente os dados das abóboras e os limpou para preservar um conjunto de dados contendo algumas variáveis, incluindo Cor. Vamos visualizar o dataframe no notebook usando a biblioteca ggplot.\n",
+    "\n",
+    "A biblioteca ggplot oferece maneiras interessantes de visualizar seus dados. Por exemplo, você pode comparar as distribuições dos dados para cada Variedade e Cor em um gráfico categórico.\n",
+    "\n",
+    "1. Crie um gráfico desse tipo usando a função geombar, com os dados das abóboras, e especifique um mapeamento de cores para cada categoria de abóbora (laranja ou branca):\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Specify colors for each value of the hue variable\n",
+    "palette <- c(ORANGE = \"orange\", WHITE = \"wheat\")\n",
+    "\n",
+    "# Create the bar plot\n",
+    "ggplot(pumpkins_select, aes(y = variety, fill = color)) +\n",
+    "  geom_bar(position = \"dodge\") +\n",
+    "  scale_fill_manual(values = palette) +\n",
+    "  labs(y = \"Variety\", fill = \"Color\") +\n",
+    "  theme_minimal()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ao observar os dados, você pode ver como as informações de Cor se relacionam com a Variedade.\n",
+    "\n",
+    "✅ Dado este gráfico categórico, quais são algumas explorações interessantes que você consegue imaginar?\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Pré-processamento de dados: codificação de características\n",
+    "\n",
+    "Nosso conjunto de dados de abóboras contém valores em formato de texto para todas as suas colunas. Trabalhar com dados categóricos é intuitivo para humanos, mas não para máquinas. Os algoritmos de aprendizado de máquina funcionam melhor com números. Por isso, a codificação é uma etapa muito importante na fase de pré-processamento de dados, pois nos permite transformar dados categóricos em dados numéricos, sem perder nenhuma informação. Uma boa codificação contribui para a construção de um bom modelo.\n",
+    "\n",
+    "Para a codificação de características, existem dois principais tipos de codificadores:\n",
+    "\n",
+    "1. Codificador ordinal: é adequado para variáveis ordinais, que são variáveis categóricas cujos dados seguem uma ordem lógica, como a coluna `item_size` no nosso conjunto de dados. Ele cria um mapeamento em que cada categoria é representada por um número, que corresponde à ordem da categoria na coluna.\n",
+    "\n",
+    "2. Codificador categórico: é adequado para variáveis nominais, que são variáveis categóricas cujos dados não seguem uma ordem lógica, como todas as características diferentes de `item_size` no nosso conjunto de dados. Trata-se de uma codificação one-hot, o que significa que cada categoria é representada por uma coluna binária: a variável codificada é igual a 1 se a abóbora pertence àquela variedade e 0 caso contrário.\n",
+    "\n",
+    "O Tidymodels oferece mais um pacote interessante: [recipes](https://recipes.tidymodels.org/) - um pacote para pré-processamento de dados. Vamos definir uma `recipe` que especifica que todas as colunas preditoras devem ser codificadas em um conjunto de números inteiros, `prep` para estimar as quantidades e estatísticas necessárias para quaisquer operações e, por fim, `bake` para aplicar os cálculos aos novos dados.\n",
+    "\n",
+    "> Normalmente, o recipes é usado como um pré-processador para modelagem, onde define quais etapas devem ser aplicadas a um conjunto de dados para prepará-lo para a modelagem. Nesse caso, é **altamente recomendado** que você use um `workflow()` em vez de estimar manualmente uma receita usando prep e bake. Veremos tudo isso em breve.\n",
+    ">\n",
+    "> No entanto, por enquanto, estamos usando recipes + prep + bake para especificar quais etapas devem ser aplicadas a um conjunto de dados para prepará-lo para análise de dados e, em seguida, extrair os dados pré-processados com as etapas aplicadas.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Preprocess and extract data to allow some data analysis\n",
+    "baked_pumpkins <- recipe(color ~ ., data = pumpkins_select) %>%\n",
+    "  # Define ordering for item_size column\n",
+    "  step_mutate(item_size = ordered(item_size, levels = c('sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo'))) %>%\n",
+    "  # Convert factors to numbers using the order defined above (Ordinal encoding)\n",
+    "  step_integer(item_size, zero_based = F) %>%\n",
+    "  # Encode all other predictors using one hot encoding\n",
+    "  step_dummy(all_nominal(), -all_outcomes(), one_hot = TRUE) %>%\n",
+    "  prep(data = pumpkin_select) %>%\n",
+    "  bake(new_data = NULL)\n",
+    "\n",
+    "# Display the first few rows of preprocessed data\n",
+    "baked_pumpkins %>% \n",
+    "  slice_head(n = 5)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "✅ Quais são as vantagens de usar um codificador ordinal para a coluna Item Size?\n",
+    "\n",
+    "### Analisar relações entre variáveis\n",
+    "\n",
+    "Agora que pré-processamos nossos dados, podemos analisar as relações entre as características e o rótulo para ter uma ideia de quão bem o modelo será capaz de prever o rótulo com base nas características. A melhor maneira de realizar esse tipo de análise é plotando os dados.  \n",
+    "Usaremos novamente a função ggplot geom_boxplot_ para visualizar as relações entre Item Size, Variety e Color em um gráfico categórico. Para melhorar a visualização dos dados, utilizaremos a coluna codificada de Item Size e a coluna não codificada de Variety.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Define the color palette\n",
+    "palette <- c(ORANGE = \"orange\", WHITE = \"wheat\")\n",
+    "\n",
+    "# We need the encoded Item Size column to use it as the x-axis values in the plot\n",
+    "pumpkins_select_plot<-pumpkins_select\n",
+    "pumpkins_select_plot$item_size <- baked_pumpkins$item_size\n",
+    "\n",
+    "# Create the grouped box plot\n",
+    "ggplot(pumpkins_select_plot, aes(x = `item_size`, y = color, fill = color)) +\n",
+    "  geom_boxplot() +\n",
+    "  facet_grid(variety ~ ., scales = \"free_x\") +\n",
+    "  scale_fill_manual(values = palette) +\n",
+    "  labs(x = \"Item Size\", y = \"\") +\n",
+    "  theme_minimal() +\n",
+    "  theme(strip.text = element_text(size = 12)) +\n",
+    "  theme(axis.text.x = element_text(size = 10)) +\n",
+    "  theme(axis.title.x = element_text(size = 12)) +\n",
+    "  theme(axis.title.y = element_blank()) +\n",
+    "  theme(legend.position = \"bottom\") +\n",
+    "  guides(fill = guide_legend(title = \"Color\")) +\n",
+    "  theme(panel.spacing = unit(0.5, \"lines\"))+\n",
+    "  theme(strip.text.y = element_text(size = 4, hjust = 0)) \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Use um gráfico swarm\n",
+    "\n",
+    "Como Cor é uma categoria binária (Branco ou Não), ela requer '[uma abordagem especializada](https://github.com/rstudio/cheatsheets/blob/main/data-visualization.pdf) para visualização'.\n",
+    "\n",
+    "Experimente um `gráfico swarm` para mostrar a distribuição de cor em relação ao item_size.\n",
+    "\n",
+    "Usaremos o [pacote ggbeeswarm](https://github.com/eclarke/ggbeeswarm), que fornece métodos para criar gráficos no estilo beeswarm usando ggplot2. Gráficos beeswarm são uma forma de plotar pontos que normalmente se sobreporiam, organizando-os lado a lado.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create beeswarm plots of color and item_size\n",
+    "baked_pumpkins %>% \n",
+    "  mutate(color = factor(color)) %>% \n",
+    "  ggplot(mapping = aes(x = color, y = item_size, color = color)) +\n",
+    "  geom_quasirandom() +\n",
+    "  scale_color_brewer(palette = \"Dark2\", direction = -1) +\n",
+    "  theme(legend.position = \"none\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Agora que temos uma ideia da relação entre as categorias binárias de cor e o grupo maior de tamanhos, vamos explorar a regressão logística para determinar a provável cor de uma abóbora.\n",
+    "\n",
+    "## Construa seu modelo\n",
+    "\n",
+    "Selecione as variáveis que você deseja usar no seu modelo de classificação e divida os dados em conjuntos de treinamento e teste. O [rsample](https://rsample.tidymodels.org/), um pacote do Tidymodels, fornece uma infraestrutura para divisão e reamostragem de dados de forma eficiente:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Split data into 80% for training and 20% for testing\n",
+    "set.seed(2056)\n",
+    "pumpkins_split <- pumpkins_select %>% \n",
+    "  initial_split(prop = 0.8)\n",
+    "\n",
+    "# Extract the data in each split\n",
+    "pumpkins_train <- training(pumpkins_split)\n",
+    "pumpkins_test <- testing(pumpkins_split)\n",
+    "\n",
+    "# Print out the first 5 rows of the training set\n",
+    "pumpkins_train %>% \n",
+    "  slice_head(n = 5)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "🙌 Estamos prontos para treinar um modelo ajustando as características de treinamento ao rótulo de treinamento (cor).\n",
+    "\n",
+    "Começaremos criando uma receita que especifica as etapas de pré-processamento que devem ser realizadas em nossos dados para prepará-los para a modelagem, ou seja: codificar variáveis categóricas em um conjunto de números inteiros. Assim como `baked_pumpkins`, criaremos uma `pumpkins_recipe`, mas não usaremos `prep` e `bake`, já que isso será incorporado em um fluxo de trabalho, como você verá em apenas alguns passos.\n",
+    "\n",
+    "Existem várias maneiras de especificar um modelo de regressão logística no Tidymodels. Veja `?logistic_reg()`. Por enquanto, especificaremos um modelo de regressão logística usando o mecanismo padrão `stats::glm()`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create a recipe that specifies preprocessing steps for modelling\n",
+    "pumpkins_recipe <- recipe(color ~ ., data = pumpkins_train) %>% \n",
+    "  step_mutate(item_size = ordered(item_size, levels = c('sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo'))) %>%\n",
+    "  step_integer(item_size, zero_based = F) %>%  \n",
+    "  step_dummy(all_nominal(), -all_outcomes(), one_hot = TRUE)\n",
+    "\n",
+    "# Create a logistic model specification\n",
+    "log_reg <- logistic_reg() %>% \n",
+    "  set_engine(\"glm\") %>% \n",
+    "  set_mode(\"classification\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Agora que temos uma receita e uma especificação de modelo, precisamos encontrar uma maneira de combiná-los em um objeto que primeiro pré-processará os dados (prep+bake nos bastidores), ajustará o modelo nos dados pré-processados e também permitirá atividades de pós-processamento, se necessário.\n",
+    "\n",
+    "No Tidymodels, esse objeto prático é chamado de [`workflow`](https://workflows.tidymodels.org/) e organiza convenientemente seus componentes de modelagem.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Bundle modelling components in a workflow\n",
+    "log_reg_wf <- workflow() %>% \n",
+    "  add_recipe(pumpkins_recipe) %>% \n",
+    "  add_model(log_reg)\n",
+    "\n",
+    "# Print out the workflow\n",
+    "log_reg_wf\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Depois que um fluxo de trabalho é *especificado*, um modelo pode ser `treinado` usando a função [`fit()`](https://tidymodels.github.io/parsnip/reference/fit.html). O fluxo de trabalho estimará uma receita e pré-processará os dados antes do treinamento, então não será necessário fazer isso manualmente usando prep e bake.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Train the model\n",
+    "wf_fit <- log_reg_wf %>% \n",
+    "  fit(data = pumpkins_train)\n",
+    "\n",
+    "# Print the trained workflow\n",
+    "wf_fit\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "O modelo exibe os coeficientes aprendidos durante o treinamento.\n",
+    "\n",
+    "Agora que treinamos o modelo usando os dados de treinamento, podemos fazer previsões nos dados de teste usando [parsnip::predict()](https://parsnip.tidymodels.org/reference/predict.model_fit.html). Vamos começar usando o modelo para prever os rótulos do nosso conjunto de teste e as probabilidades para cada rótulo. Quando a probabilidade for maior que 0,5, a classe prevista será `WHITE`, caso contrário, será `ORANGE`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Make predictions for color and corresponding probabilities\n",
+    "results <- pumpkins_test %>% select(color) %>% \n",
+    "  bind_cols(wf_fit %>% \n",
+    "              predict(new_data = pumpkins_test)) %>%\n",
+    "  bind_cols(wf_fit %>%\n",
+    "              predict(new_data = pumpkins_test, type = \"prob\"))\n",
+    "\n",
+    "# Compare predictions\n",
+    "results %>% \n",
+    "  slice_head(n = 10)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Muito bom! Isso oferece mais insights sobre como a regressão logística funciona.\n",
+    "\n",
+    "### Melhor compreensão por meio de uma matriz de confusão\n",
+    "\n",
+    "Comparar cada previsão com seu respectivo valor real (\"ground truth\") não é uma maneira muito eficiente de determinar o quão bem o modelo está prevendo. Felizmente, o Tidymodels tem mais algumas cartas na manga: [`yardstick`](https://yardstick.tidymodels.org/) - um pacote usado para medir a eficácia de modelos utilizando métricas de desempenho.\n",
+    "\n",
+    "Uma métrica de desempenho associada a problemas de classificação é a [`matriz de confusão`](https://wikipedia.org/wiki/Confusion_matrix). Uma matriz de confusão descreve o quão bem um modelo de classificação está performando. Ela tabula quantos exemplos de cada classe foram classificados corretamente por um modelo. No nosso caso, ela mostrará quantas abóboras laranjas foram classificadas como laranjas e quantas abóboras brancas foram classificadas como brancas; a matriz de confusão também mostra quantas foram classificadas nas categorias **erradas**.\n",
+    "\n",
+    "A função [**`conf_mat()`**](https://tidymodels.github.io/yardstick/reference/conf_mat.html) do yardstick calcula essa tabela cruzada de classes observadas e previstas.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Confusion matrix for prediction results\n",
+    "conf_mat(data = results, truth = color, estimate = .pred_class)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vamos interpretar a matriz de confusão. Nosso modelo foi solicitado a classificar abóboras entre duas categorias binárias, a categoria `branca` e a categoria `não-branca`.\n",
+    "\n",
+    "-   Se o seu modelo prevê que uma abóbora é branca e ela realmente pertence à categoria 'branca', chamamos isso de `verdadeiro positivo`, representado pelo número no canto superior esquerdo.\n",
+    "\n",
+    "-   Se o seu modelo prevê que uma abóbora não é branca e ela realmente pertence à categoria 'branca', chamamos isso de `falso negativo`, representado pelo número no canto inferior esquerdo.\n",
+    "\n",
+    "-   Se o seu modelo prevê que uma abóbora é branca e ela realmente pertence à categoria 'não-branca', chamamos isso de `falso positivo`, representado pelo número no canto superior direito.\n",
+    "\n",
+    "-   Se o seu modelo prevê que uma abóbora não é branca e ela realmente pertence à categoria 'não-branca', chamamos isso de `verdadeiro negativo`, representado pelo número no canto inferior direito.\n",
+    "\n",
+    "| Verdade |\n",
+    "|:-------:|\n",
+    "\n",
+    "|               |        |       |\n",
+    "|---------------|--------|-------|\n",
+    "| **Previsto**  | BRANCA | LARANJA |\n",
+    "| BRANCA        | VP     | FP    |\n",
+    "| LARANJA       | FN     | VN    |\n",
+    "\n",
+    "Como você deve ter imaginado, é preferível ter um número maior de verdadeiros positivos e verdadeiros negativos e um número menor de falsos positivos e falsos negativos, o que implica que o modelo tem um desempenho melhor.\n",
+    "\n",
+    "A matriz de confusão é útil porque dá origem a outras métricas que podem nos ajudar a avaliar melhor o desempenho de um modelo de classificação. Vamos analisar algumas delas:\n",
+    "\n",
+    "🎓 Precisão: `VP/(VP + FP)` definida como a proporção de positivos previstos que são realmente positivos. Também chamada de [valor preditivo positivo](https://en.wikipedia.org/wiki/Positive_predictive_value \"Positive predictive value\").\n",
+    "\n",
+    "🎓 Revocação: `VP/(VP + FN)` definida como a proporção de resultados positivos em relação ao número de amostras que eram realmente positivas. Também conhecida como `sensibilidade`.\n",
+    "\n",
+    "🎓 Especificidade: `VN/(VN + FP)` definida como a proporção de resultados negativos em relação ao número de amostras que eram realmente negativas.\n",
+    "\n",
+    "🎓 Acurácia: `VP + VN/(VP + VN + FP + FN)` A porcentagem de rótulos previstos corretamente para uma amostra.\n",
+    "\n",
+    "🎓 Medida F: Uma média ponderada entre a precisão e a revocação, sendo 1 o melhor valor e 0 o pior.\n",
+    "\n",
+    "Vamos calcular essas métricas!\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Combine metric functions and calculate them all at once\n",
+    "eval_metrics <- metric_set(ppv, recall, spec, f_meas, accuracy)\n",
+    "eval_metrics(data = results, truth = color, estimate = .pred_class)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualizar a curva ROC deste modelo\n",
+    "\n",
+    "Vamos fazer mais uma visualização para observar a chamada [`curva ROC`](https://en.wikipedia.org/wiki/Receiver_operating_characteristic):\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Make a roc_curve\n",
+    "results %>% \n",
+    "  roc_curve(color, .pred_ORANGE) %>% \n",
+    "  autoplot()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Curvas ROC são frequentemente usadas para obter uma visão do desempenho de um classificador em termos de verdadeiros positivos versus falsos positivos. Curvas ROC geralmente apresentam a `Taxa de Verdadeiros Positivos`/Sensibilidade no eixo Y e a `Taxa de Falsos Positivos`/1-Especificidade no eixo X. Assim, a inclinação da curva e o espaço entre a linha do ponto médio e a curva são importantes: você quer uma curva que rapidamente suba e ultrapasse a linha. No nosso caso, há falsos positivos no início, e então a linha sobe e ultrapassa adequadamente.\n",
+    "\n",
+    "Por fim, vamos usar `yardstick::roc_auc()` para calcular a Área Sob a Curva. Uma forma de interpretar a AUC é como a probabilidade de que o modelo classifique um exemplo positivo aleatório mais alto do que um exemplo negativo aleatório.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "r"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Calculate area under curve\n",
+    "results %>% \n",
+    "  roc_auc(color, .pred_ORANGE)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "O resultado é cerca de `0.975`. Dado que o AUC varia de 0 a 1, você quer um valor alto, já que um modelo que acerta 100% das previsões terá um AUC de 1; neste caso, o modelo é *muito bom*.\n",
+    "\n",
+    "Em futuras lições sobre classificações, você aprenderá como melhorar os resultados do seu modelo (como lidar com dados desbalanceados neste caso).\n",
+    "\n",
+    "## 🚀Desafio\n",
+    "\n",
+    "Há muito mais para explorar sobre regressão logística! Mas a melhor forma de aprender é experimentando. Encontre um conjunto de dados que se preste a esse tipo de análise e construa um modelo com ele. O que você aprende? dica: experimente [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) para conjuntos de dados interessantes.\n",
+    "\n",
+    "## Revisão & Estudo Individual\n",
+    "\n",
+    "Leia as primeiras páginas [deste artigo de Stanford](https://web.stanford.edu/~jurafsky/slp3/5.pdf) sobre alguns usos práticos da regressão logística. Pense em tarefas que são mais adequadas para um ou outro tipo de regressão entre as que estudamos até agora. O que funcionaria melhor?\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n---\n\n**Aviso Legal**:  \nEste documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": "",
+  "kernelspec": {
+   "display_name": "R",
+   "langauge": "R",
+   "name": "ir"
+  },
+  "language_info": {
+   "codemirror_mode": "r",
+   "file_extension": ".r",
+   "mimetype": "text/x-r-source",
+   "name": "R",
+   "pygments_lexer": "r",
+   "version": "3.4.1"
+  },
+  "coopTranslator": {
+   "original_hash": "feaf125f481a89c468fa115bf2aed580",
+   "translation_date": "2025-08-29T23:04:05+00:00",
+   "source_file": "2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb",
+   "language_code": "br"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

translations/pt-BR/2-Regression/README.md

@@ -0,0 +1,45 @@
+# Modelos de regressão para aprendizado de máquina
+## Tópico regional: Modelos de regressão para preços de abóboras na América do Norte 🎃
+
+Na América do Norte, as abóboras são frequentemente esculpidas em rostos assustadores para o Halloween. Vamos descobrir mais sobre esses vegetais fascinantes!
+
+![jack-o-lanterns](../../../translated_images/pt-BR/jack-o-lanterns.181c661a9212457d.webp)
+> Foto de <a href="https://unsplash.com/@teutschmann?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Beth Teutschmann</a> no <a href="https://unsplash.com/s/photos/jack-o-lanterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
+  
+## O que você vai aprender
+
+[![Introdução à Regressão](https://img.youtube.com/vi/5QnJtDad4iQ/0.jpg)](https://youtu.be/5QnJtDad4iQ "Vídeo de introdução à regressão - Clique para assistir!")
+> 🎥 Clique na imagem acima para um vídeo rápido de introdução a esta lição
+
+As lições desta seção abordam os tipos de regressão no contexto do aprendizado de máquina. Os modelos de regressão podem ajudar a determinar o _relacionamento_ entre variáveis. Esse tipo de modelo pode prever valores como comprimento, temperatura ou idade, revelando assim relações entre variáveis enquanto analisa pontos de dados.
+
+Nesta série de lições, você descobrirá as diferenças entre regressão linear e logística, e quando deve preferir uma em vez da outra.
+
+[![ML para iniciantes - Introdução aos modelos de regressão para aprendizado de máquina](https://img.youtube.com/vi/XA3OaoW86R8/0.jpg)](https://youtu.be/XA3OaoW86R8 "ML para iniciantes - Introdução aos modelos de regressão para aprendizado de máquina")
+
+> 🎥 Clique na imagem acima para um vídeo curto apresentando os modelos de regressão.
+
+Neste grupo de lições, você será preparado para começar tarefas de aprendizado de máquina, incluindo a configuração do Visual Studio Code para gerenciar notebooks, o ambiente comum para cientistas de dados. Você descobrirá o Scikit-learn, uma biblioteca para aprendizado de máquina, e construirá seus primeiros modelos, com foco nos modelos de regressão neste capítulo.
+
+> Existem ferramentas úteis de baixo código que podem ajudá-lo a aprender sobre o trabalho com modelos de regressão. Experimente [Azure ML para esta tarefa](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
+
+### Lições
+
+1. [Ferramentas do ofício](1-Tools/README.md)
+2. [Gerenciando dados](2-Data/README.md)
+3. [Regressão linear e polinomial](3-Linear/README.md)
+4. [Regressão logística](4-Logistic/README.md)
+
+---
+### Créditos
+
+"ML com regressão" foi escrito com ♥️ por [Jen Looper](https://twitter.com/jenlooper)
+
+♥️ Contribuidores do quiz incluem: [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan) e [Ornella Altunyan](https://twitter.com/ornelladotcom)
+
+O conjunto de dados de abóboras foi sugerido por [este projeto no Kaggle](https://www.kaggle.com/usda/a-year-of-pumpkin-prices) e seus dados são provenientes dos [Relatórios Padrão dos Mercados de Culturas Especiais](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuídos pelo Departamento de Agricultura dos Estados Unidos. Adicionamos alguns pontos relacionados à cor com base na variedade para normalizar a distribuição. Esses dados estão em domínio público.
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

translations/pt-BR/3-Web-App/1-Web-App/README.md

@@ -0,0 +1,350 @@
+# Construa um Aplicativo Web para Usar um Modelo de ML
+
+Nesta lição, você irá treinar um modelo de ML em um conjunto de dados que é fora deste mundo: _avistamentos de OVNIs ao longo do último século_, obtidos do banco de dados do NUFORC.
+
+Você aprenderá:
+
+- Como 'pickle' um modelo treinado
+- Como usar esse modelo em um aplicativo Flask
+
+Continuaremos utilizando notebooks para limpar os dados e treinar nosso modelo, mas você pode levar o processo um passo adiante explorando o uso de um modelo "na prática", por assim dizer: em um aplicativo web.
+
+Para fazer isso, você precisa construir um aplicativo web usando Flask.
+
+## [Quiz pré-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+## Construindo um aplicativo
+
+Existem várias maneiras de construir aplicativos web para consumir modelos de aprendizado de máquina. Sua arquitetura web pode influenciar a forma como seu modelo é treinado. Imagine que você está trabalhando em uma empresa onde o grupo de ciência de dados treinou um modelo que eles querem que você use em um aplicativo.
+
+### Considerações
+
+Há muitas perguntas que você precisa fazer:
+
+- **É um aplicativo web ou um aplicativo móvel?** Se você está construindo um aplicativo móvel ou precisa usar o modelo em um contexto de IoT, você pode usar [TensorFlow Lite](https://www.tensorflow.org/lite/) e utilizar o modelo em um aplicativo Android ou iOS.
+- **Onde o modelo ficará armazenado?** Na nuvem ou localmente?
+- **Suporte offline.** O aplicativo precisa funcionar offline?
+- **Qual tecnologia foi usada para treinar o modelo?** A tecnologia escolhida pode influenciar as ferramentas que você precisa usar.
+    - **Usando TensorFlow.** Se você está treinando um modelo usando TensorFlow, por exemplo, esse ecossistema oferece a capacidade de converter um modelo TensorFlow para uso em um aplicativo web usando [TensorFlow.js](https://www.tensorflow.org/js/).
+    - **Usando PyTorch.** Se você está construindo um modelo usando uma biblioteca como [PyTorch](https://pytorch.org/), você tem a opção de exportá-lo no formato [ONNX](https://onnx.ai/) (Open Neural Network Exchange) para uso em aplicativos web JavaScript que podem usar o [Onnx Runtime](https://www.onnxruntime.ai/). Essa opção será explorada em uma lição futura para um modelo treinado com Scikit-learn.
+    - **Usando Lobe.ai ou Azure Custom Vision.** Se você está usando um sistema de ML SaaS (Software como Serviço) como [Lobe.ai](https://lobe.ai/) ou [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott) para treinar um modelo, esse tipo de software oferece maneiras de exportar o modelo para várias plataformas, incluindo a construção de uma API personalizada para ser consultada na nuvem pelo seu aplicativo online.
+
+Você também tem a oportunidade de construir um aplicativo web Flask completo que seria capaz de treinar o modelo diretamente em um navegador web. Isso também pode ser feito usando TensorFlow.js em um contexto JavaScript.
+
+Para nossos propósitos, já que estamos trabalhando com notebooks baseados em Python, vamos explorar os passos necessários para exportar um modelo treinado de um notebook para um formato legível por um aplicativo web construído em Python.
+
+## Ferramenta
+
+Para esta tarefa, você precisa de duas ferramentas: Flask e Pickle, ambas executadas em Python.
+
+✅ O que é [Flask](https://palletsprojects.com/p/flask/)? Definido como um 'micro-framework' por seus criadores, Flask fornece os recursos básicos de frameworks web usando Python e um mecanismo de templates para construir páginas web. Confira [este módulo de aprendizado](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott) para praticar a construção com Flask.
+
+✅ O que é [Pickle](https://docs.python.org/3/library/pickle.html)? Pickle 🥒 é um módulo Python que serializa e desserializa uma estrutura de objeto Python. Quando você 'pickle' um modelo, você serializa ou achata sua estrutura para uso na web. Cuidado: pickle não é intrinsecamente seguro, então tenha cuidado se for solicitado a 'despickle' um arquivo. Um arquivo pickled tem o sufixo `.pkl`.
+
+## Exercício - limpe seus dados
+
+Nesta lição, você usará dados de 80.000 avistamentos de OVNIs, coletados pelo [NUFORC](https://nuforc.org) (Centro Nacional de Relatórios de OVNIs). Esses dados têm algumas descrições interessantes de avistamentos de OVNIs, por exemplo:
+
+- **Descrição longa de exemplo.** "Um homem emerge de um feixe de luz que brilha em um campo gramado à noite e corre em direção ao estacionamento da Texas Instruments".
+- **Descrição curta de exemplo.** "as luzes nos perseguiram".
+
+A planilha [ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv) inclui colunas sobre a `cidade`, `estado` e `país` onde o avistamento ocorreu, o `formato` do objeto e sua `latitude` e `longitude`.
+
+No [notebook](../../../../3-Web-App/1-Web-App/notebook.ipynb) em branco incluído nesta lição:
+
+1. Importe `pandas`, `matplotlib` e `numpy` como você fez em lições anteriores e importe a planilha de OVNIs. Você pode dar uma olhada em um conjunto de dados de amostra:
+
+    ```python
+    import pandas as pd
+    import numpy as np
+    
+    ufos = pd.read_csv('./data/ufos.csv')
+    ufos.head()
+    ```
+
+1. Converta os dados de OVNIs para um pequeno dataframe com títulos novos. Verifique os valores únicos no campo `Country`.
+
+    ```python
+    ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
+    
+    ufos.Country.unique()
+    ```
+
+1. Agora, você pode reduzir a quantidade de dados com que precisamos lidar, descartando quaisquer valores nulos e importando apenas avistamentos entre 1-60 segundos:
+
+    ```python
+    ufos.dropna(inplace=True)
+    
+    ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
+    
+    ufos.info()
+    ```
+
+1. Importe a biblioteca `LabelEncoder` do Scikit-learn para converter os valores de texto dos países em números:
+
+    ✅ LabelEncoder codifica dados alfabeticamente
+
+    ```python
+    from sklearn.preprocessing import LabelEncoder
+    
+    ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
+    
+    ufos.head()
+    ```
+
+    Seus dados devem se parecer com isto:
+
+    ```output
+    	Seconds	Country	Latitude	Longitude
+    2	20.0	3		53.200000	-2.916667
+    3	20.0	4		28.978333	-96.645833
+    14	30.0	4		35.823889	-80.253611
+    23	60.0	4		45.582778	-122.352222
+    24	3.0		3		51.783333	-0.783333
+    ```
+
+## Exercício - construa seu modelo
+
+Agora você pode se preparar para treinar um modelo dividindo os dados em grupos de treinamento e teste.
+
+1. Selecione as três características que você deseja treinar como seu vetor X, e o vetor y será o `Country`. Você quer ser capaz de inserir `Seconds`, `Latitude` e `Longitude` e obter um id de país como retorno.
+
+    ```python
+    from sklearn.model_selection import train_test_split
+    
+    Selected_features = ['Seconds','Latitude','Longitude']
+    
+    X = ufos[Selected_features]
+    y = ufos['Country']
+    
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+    ```
+
+1. Treine seu modelo usando regressão logística:
+
+    ```python
+    from sklearn.metrics import accuracy_score, classification_report
+    from sklearn.linear_model import LogisticRegression
+    model = LogisticRegression()
+    model.fit(X_train, y_train)
+    predictions = model.predict(X_test)
+    
+    print(classification_report(y_test, predictions))
+    print('Predicted labels: ', predictions)
+    print('Accuracy: ', accuracy_score(y_test, predictions))
+    ```
+
+A precisão não é ruim **(cerca de 95%)**, o que não é surpreendente, já que `Country` e `Latitude/Longitude` estão correlacionados.
+
+O modelo que você criou não é muito revolucionário, já que você deveria ser capaz de inferir um `Country` a partir de sua `Latitude` e `Longitude`, mas é um bom exercício para tentar treinar a partir de dados brutos que você limpou, exportou e depois usou esse modelo em um aplicativo web.
+
+## Exercício - 'pickle' seu modelo
+
+Agora é hora de _pickle_ seu modelo! Você pode fazer isso em algumas linhas de código. Uma vez que ele esteja _pickled_, carregue seu modelo pickled e teste-o contra um array de dados de amostra contendo valores para segundos, latitude e longitude.
+
+```python
+import pickle
+model_filename = 'ufo-model.pkl'
+pickle.dump(model, open(model_filename,'wb'))
+
+model = pickle.load(open('ufo-model.pkl','rb'))
+print(model.predict([[50,44,-12]]))
+```
+
+O modelo retorna **'3'**, que é o código do país para o Reino Unido. Incrível! 👽
+
+## Exercício - construa um aplicativo Flask
+
+Agora você pode construir um aplicativo Flask para chamar seu modelo e retornar resultados semelhantes, mas de uma maneira mais visualmente agradável.
+
+1. Comece criando uma pasta chamada **web-app** ao lado do arquivo _notebook.ipynb_ onde seu arquivo _ufo-model.pkl_ está localizado.
+
+1. Nessa pasta, crie mais três pastas: **static**, com uma pasta **css** dentro dela, e **templates**. Você deve ter os seguintes arquivos e diretórios:
+
+    ```output
+    web-app/
+      static/
+        css/
+      templates/
+    notebook.ipynb
+    ufo-model.pkl
+    ```
+
+    ✅ Consulte a pasta de solução para ver o aplicativo finalizado
+
+1. O primeiro arquivo a ser criado na pasta _web-app_ é o arquivo **requirements.txt**. Como o _package.json_ em um aplicativo JavaScript, este arquivo lista as dependências necessárias para o aplicativo. No **requirements.txt** adicione as linhas:
+
+    ```text
+    scikit-learn
+    pandas
+    numpy
+    flask
+    ```
+
+1. Agora, execute este arquivo navegando até _web-app_:
+
+    ```bash
+    cd web-app
+    ```
+
+1. No seu terminal, digite `pip install` para instalar as bibliotecas listadas no _requirements.txt_:
+
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+1. Agora, você está pronto para criar mais três arquivos para finalizar o aplicativo:
+
+    1. Crie **app.py** na raiz.
+    2. Crie **index.html** no diretório _templates_.
+    3. Crie **styles.css** no diretório _static/css_.
+
+1. Desenvolva o arquivo _styles.css_ com alguns estilos:
+
+    ```css
+    body {
+    	width: 100%;
+    	height: 100%;
+    	font-family: 'Helvetica';
+    	background: black;
+    	color: #fff;
+    	text-align: center;
+    	letter-spacing: 1.4px;
+    	font-size: 30px;
+    }
+    
+    input {
+    	min-width: 150px;
+    }
+    
+    .grid {
+    	width: 300px;
+    	border: 1px solid #2d2d2d;
+    	display: grid;
+    	justify-content: center;
+    	margin: 20px auto;
+    }
+    
+    .box {
+    	color: #fff;
+    	background: #2d2d2d;
+    	padding: 12px;
+    	display: inline-block;
+    }
+    ```
+
+1. Em seguida, desenvolva o arquivo _index.html_:
+
+    ```html
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <meta charset="UTF-8">
+        <title>🛸 UFO Appearance Prediction! 👽</title>
+        <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+      </head>
+    
+      <body>
+        <div class="grid">
+    
+          <div class="box">
+    
+            <p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
+    
+            <form action="{{ url_for('predict')}}" method="post">
+              <input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
+              <input type="text" name="latitude" placeholder="Latitude" required="required" />
+              <input type="text" name="longitude" placeholder="Longitude" required="required" />
+              <button type="submit" class="btn">Predict country where the UFO is seen</button>
+            </form>
+    
+            <p>{{ prediction_text }}</p>
+    
+          </div>
+    
+        </div>
+    
+      </body>
+    </html>
+    ```
+
+    Observe o uso de templates neste arquivo. Note a sintaxe 'mustache' ao redor das variáveis que serão fornecidas pelo aplicativo, como o texto de previsão: `{{}}`. Há também um formulário que envia uma previsão para a rota `/predict`.
+
+    Finalmente, você está pronto para construir o arquivo Python que dirige o consumo do modelo e a exibição das previsões:
+
+1. No `app.py` adicione:
+
+    ```python
+    import numpy as np
+    from flask import Flask, request, render_template
+    import pickle
+    
+    app = Flask(__name__)
+    
+    model = pickle.load(open("./ufo-model.pkl", "rb"))
+    
+    
+    @app.route("/")
+    def home():
+        return render_template("index.html")
+    
+    
+    @app.route("/predict", methods=["POST"])
+    def predict():
+    
+        int_features = [int(x) for x in request.form.values()]
+        final_features = [np.array(int_features)]
+        prediction = model.predict(final_features)
+    
+        output = prediction[0]
+    
+        countries = ["Australia", "Canada", "Germany", "UK", "US"]
+    
+        return render_template(
+            "index.html", prediction_text="Likely country: {}".format(countries[output])
+        )
+    
+    
+    if __name__ == "__main__":
+        app.run(debug=True)
+    ```
+
+    > 💡 Dica: quando você adiciona [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) ao executar o aplicativo web usando Flask, quaisquer alterações feitas no seu aplicativo serão refletidas imediatamente sem a necessidade de reiniciar o servidor. Atenção! Não habilite este modo em um aplicativo de produção.
+
+Se você executar `python app.py` ou `python3 app.py` - seu servidor web será iniciado localmente, e você poderá preencher um formulário curto para obter uma resposta à sua pergunta sobre onde os OVNIs foram avistados!
+
+Antes de fazer isso, dê uma olhada nas partes do `app.py`:
+
+1. Primeiro, as dependências são carregadas e o aplicativo é iniciado.
+1. Em seguida, o modelo é importado.
+1. Depois, o index.html é renderizado na rota inicial.
+
+Na rota `/predict`, várias coisas acontecem quando o formulário é enviado:
+
+1. As variáveis do formulário são coletadas e convertidas em um array numpy. Elas são então enviadas ao modelo e uma previsão é retornada.
+2. Os países que queremos exibir são re-renderizados como texto legível a partir de seu código de país previsto, e esse valor é enviado de volta ao index.html para ser renderizado no template.
+
+Usar um modelo dessa forma, com Flask e um modelo pickled, é relativamente simples. O mais difícil é entender qual é o formato dos dados que devem ser enviados ao modelo para obter uma previsão. Isso depende de como o modelo foi treinado. Este modelo requer três pontos de dados para ser inserido e obter uma previsão.
+
+Em um ambiente profissional, você pode ver como é importante ter uma boa comunicação entre as pessoas que treinam o modelo e aquelas que o consomem em um aplicativo web ou móvel. No nosso caso, é apenas uma pessoa: você!
+
+---
+
+## 🚀 Desafio
+
+Em vez de trabalhar em um notebook e importar o modelo para o aplicativo Flask, você poderia treinar o modelo diretamente dentro do aplicativo Flask! Tente converter seu código Python no notebook, talvez após limpar seus dados, para treinar o modelo dentro do aplicativo em uma rota chamada `train`. Quais são os prós e contras de seguir esse método?
+
+## [Quiz pós-aula](https://ff-quizzes.netlify.app/en/ml/)
+
+## Revisão e Autoestudo
+
+Existem muitas maneiras de construir um aplicativo web para consumir modelos de ML. Faça uma lista das maneiras que você poderia usar JavaScript ou Python para construir um aplicativo web que aproveite o aprendizado de máquina. Considere a arquitetura: o modelo deve permanecer no aplicativo ou viver na nuvem? Se for o último caso, como você o acessaria? Desenhe um modelo arquitetural para uma solução de ML aplicada em um aplicativo web.
+
+## Tarefa
+
+[Experimente um modelo diferente](assignment.md)
+
+---
+
+**Aviso Legal**:  
+Este documento foi traduzido utilizando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.