ಕೋಡ್ ಜನರೇಷನ್: ಪೈಥಾನ್ (ಪಾಂಡಾಗಳು) ಮತ್ತು SQL ಜೊತೆ AI-ಸಹಾಯದ ವಿಶ್ಲೇಷಣೆ

ಲಾಭಗಳು:

• ದೃಢವಾದ SQL ಮತ್ತು ಪಾಂಡಾಸ್ ಕೋಡ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯ ಮತ್ತು ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಗೆ ಸ್ಪಷ್ಟವಾದ ಸ್ಕೀಮಾ ಮತ್ತು ಉದ್ದೇಶವನ್ನು ನೀಡುವ ಮೂಲಕ ಅದನ್ನು ಸಾಲಿನ ಮೂಲಕ ಓದುವ ಮತ್ತು ಪರಿಶೀಲಿಸುವ ಸಾಮರ್ಥ್ಯ
• ಸಾಲು ಎಣಿಕೆ, ಫಿಟ್ಟಿಂಗ್ ಫಂಕ್ಷನ್ ಮತ್ತು ವಿಲೀನ/ಸೇರಿದ ನಂತರ ಥ್ರೋಪುಟ್‌ನಂತಹ ಮೂಕ ದೋಷಗಳನ್ನು ಹಿಡಿಯುವ ಸಾಮರ್ಥ್ಯ
• ಡೀಬಗ್‌ನಲ್ಲಿ ಸಮಸ್ಯೆಯನ್ನು ನಿಶ್ಯಬ್ದಗೊಳಿಸದೆ ಪರಿಹರಿಸುವ ಸಾಮರ್ಥ್ಯ ಮತ್ತು ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ಅದನ್ನು ಪರೀಕ್ಷಿಸದೆ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸುವುದನ್ನು ತಪ್ಪಿಸುವುದು

ದತ್ತಾಂಶ ವಿಜ್ಞಾನವು ಎರಡು ಪ್ರಾಥಮಿಕ ಭಾಷೆಗಳನ್ನು ಹೊಂದಿದೆ: SQL (ರಚನಾತ್ಮಕ ಪ್ರಶ್ನೆ ಭಾಷೆ - ಡೇಟಾಬೇಸ್‌ಗಳಿಂದ ಡೇಟಾವನ್ನು ಪ್ರಶ್ನಿಸುವ ಭಾಷೆ) ಮತ್ತು ಪೈಥಾನ್ (ನಿರ್ದಿಷ್ಟವಾಗಿ, ಪಾಂಡಾಸ್ ಲೈಬ್ರರಿ - ಕೋಷ್ಟಕಗಳನ್ನು ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್‌ನಲ್ಲಿ ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುವ ಪ್ರಮಾಣಿತ ಸಾಧನ). ಈ ಘಟಕದಲ್ಲಿ, ನಾವು AI ಅನ್ನು ಕೋಡ್ ಪಾಲುದಾರರಾಗಿ ಬಳಸಲು ಕಲಿಯುತ್ತೇವೆ: ಸರಿಯಾದ ಪ್ರಶ್ನೆಗಳೊಂದಿಗೆ ಅದರಿಂದ ಘನ SQL ಮತ್ತು ಪಾಂಡಾಸ್ ಕೋಡ್ ಪಡೆಯುವುದು, ಆ ಕೋಡ್ ಅನ್ನು ಓದುವುದು ಮತ್ತು ಮೌಲ್ಯೀಕರಿಸುವುದು, ಅದನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು ಮತ್ತು ಅದನ್ನು ಎಂದಿಗೂ ಕುರುಡಾಗಿ ಚಲಾಯಿಸುವುದಿಲ್ಲ. AI ನಿಮಿಷಗಳ ಬದಲಿಗೆ ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಪುನರಾವರ್ತಿತ ಕೋಡ್ ಅನ್ನು ಬರೆಯುತ್ತದೆ; ಆದರೆ ಅದು ಉತ್ಪಾದಿಸುವ ಕೋಡ್ ಸರಿಯಾದ ಕಾಲಮ್ ಅನ್ನು ಸರಿಯಾದ ತರ್ಕದೊಂದಿಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ನಿಮ್ಮ ಕೆಲಸ. ವರ್ಕಿಂಗ್ ಕೋಡ್ ಎಂದರೆ ಸರಿಯಾದ ಕೋಡ್ ಎಂದಲ್ಲ.

AI ನೊಂದಿಗೆ ಕೋಡ್ ಅನ್ನು ಏಕೆ ಉತ್ಪಾದಿಸುವುದು ಶಕ್ತಿಯುತವಾಗಿದೆ ಆದರೆ ಅಪಾಯಕಾರಿಯಾಗಿದೆ

ಕೋಡ್ ಉತ್ಪಾದನೆಯಲ್ಲಿ AI ಮೂರು ದೊಡ್ಡ ಪ್ರಯೋಜನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: ವೇಗ (ಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ 30-ಲೈನ್ ಗ್ರೂಪ್‌ಬೈ-ಪಿವೋಟ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬರೆಯುತ್ತದೆ), ಜ್ಞಾಪನೆ (ನೀವು ಮರೆತಿರುವ ಪಾಂಡಾಗಳ ಕಾರ್ಯವನ್ನು ನಿಮಗೆ ನೆನಪಿಸುತ್ತದೆ) ಮತ್ತು ಬೋಧನೆ (ಕೋಡ್ ಲೈನ್ ಅನ್ನು ಸಾಲಿನ ಮೂಲಕ ವಿವರಿಸುತ್ತದೆ). ಆದರೆ ಇದು ಮೂರು ಅಪಾಯಗಳನ್ನು ಹೊಂದಿದೆ: ಮೂಕ ತರ್ಕ ದೋಷ (ತಪ್ಪು ಕಾಲಮ್ ದೋಷಗಳಿಲ್ಲದೆ ಚಲಿಸುವ ಕೋಡ್), ಅಳವಡಿಸಲಾದ ಕಾರ್ಯ (ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ವಿಧಾನವನ್ನು ಸೂಚಿಸುತ್ತದೆ), ಮತ್ತು ಇಳುವರಿ ಟ್ರ್ಯಾಪ್ (ಸಣ್ಣ ಡೇಟಾದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕೋಡ್ ಆದರೆ 10 ಮಿಲಿಯನ್ ಸಾಲುಗಳಲ್ಲಿ ಕ್ರ್ಯಾಶ್ ಆಗುತ್ತದೆ). ಆದ್ದರಿಂದ ಸುವರ್ಣ ನಿಯಮ: AI ನ ಕೋಡ್ ಅನ್ನು ನೀವೇ ಬರೆದಂತೆ ಓದಿ. ನಿಮಗೆ ಅರ್ಥವಾಗದ ಸಾಲನ್ನು ಓಡಿಸಬೇಡಿ.

SQL: ಮೂಲದಲ್ಲಿ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ

ಡೇಟಾಬೇಸ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯಲು ಮತ್ತು ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು SQL ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ; ಪೈಥಾನ್‌ಗೆ ಎಳೆಯದೆಯೇ ನೀವು ಲಕ್ಷಾಂತರ ಸಾಲುಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಬಹುದು. ಮೂಲ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್‌ಗಳು: ಆಯ್ಕೆ (ಯಾವ ಕಾಲಮ್‌ಗಳು), ಎಲ್ಲಿ (ಯಾವ ಸಾಲುಗಳು), ಗುಂಪು ಮೂಲಕ (ಗುಂಪು ಮತ್ತು ಸಾರಾಂಶ), ಸೇರಿಕೊಳ್ಳಿ (ಕೋಷ್ಟಕಗಳನ್ನು ಸೇರಿಕೊಳ್ಳಿ), ಹೊಂದಿರುವುದು (ಪೋಸ್ಟ್-ಗ್ರೂಪ್ ಫಿಲ್ಟರ್). ಸಂಕೀರ್ಣವಾದ ಸೇರ್ಪಡೆಗಳು ಮತ್ತು ವಿಂಡೋ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯುವಲ್ಲಿ AI ತುಂಬಾ ಸಹಾಯಕವಾಗಿದೆ, ಆದರೆ ಎರಡು ವಿಷಯಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಮರೆಯದಿರಿ: ಸರಿಯಾದ ಕೀ (ತಪ್ಪಾದ ಕೀ ನಕಲು ಸಾಲುಗಳು) ಮೂಲಕ JOIN ಆಗಿದೆ ಮತ್ತು ಫಿಲ್ಟರ್ ತರ್ಕ ಸರಿಯಾಗಿದೆ (ವಿಶೇಷವಾಗಿ NULL ನಡವಳಿಕೆ ಮತ್ತು ದಿನಾಂಕ ಶ್ರೇಣಿಗಳು).

ಎಚ್ಚರಿಕೆ: ಪ್ರೊಡಕ್ಷನ್ ಡೇಟಾಬೇಸ್ ವಿರುದ್ಧ ನೇರವಾಗಿ AI- ರಚಿತ SQL ಪ್ರಶ್ನೆಯನ್ನು ರನ್ ಮಾಡಬೇಡಿ. ಸಣ್ಣ ಪ್ರತಿಯೊಂದಿಗೆ ಪರೀಕ್ಷಿಸಿ ಅಥವಾ ಮೊದಲು ಮಿತಿಗೊಳಿಸಿ. WHERE ಸ್ಥಿತಿಯನ್ನು ಮೌಲ್ಯೀಕರಿಸದೆ UPDATE/DELETE ಪ್ರಶ್ನೆಯನ್ನು ಎಂದಿಗೂ ರನ್ ಮಾಡಬೇಡಿ; ಸಂಪೂರ್ಣ ಟೇಬಲ್ ಅನ್ನು ಎಲ್ಲಿ ಅಳಿಸಬಹುದು ಎಂಬ ತಪ್ಪು.

ಪೈಥಾನ್/ಪಾಂಡಗಳು: ಹೊಂದಿಕೊಳ್ಳುವ ವಿಶ್ಲೇಷಣೆ

ಪೈಥಾನ್‌ನಲ್ಲಿ ಕೋಷ್ಟಕಗಳನ್ನು (ಡೇಟಾಫ್ರೇಮ್) ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ಪಾಂಡಾಗಳು ಪ್ರಮಾಣಿತ ಮಾರ್ಗವಾಗಿದೆ. AI ಯ ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಬಳಕೆಯೆಂದರೆ ಅದಕ್ಕೆ ಸ್ಪಷ್ಟ ಯೋಜನೆ ಮತ್ತು ಉದ್ದೇಶವನ್ನು ನೀಡುವುದು. ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಕಾರ್ಯಾಚರಣೆಗಳು: ಫಿಲ್ಟರ್, ಗ್ರೂಪ್‌ಬೈ, ವಿಲೀನ, ಪಿವೋಟ್_ಟೇಬಲ್, ಅನ್ವಯಿಸಿ. AI ಇವುಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಬರೆಯುತ್ತದೆ; ನೀವು ಪರಿಶೀಲಿಸಲು ಬಯಸುವುದು ತರ್ಕವಾಗಿದೆ: ಸರಿಯಾದ ಕಾಲಮ್‌ನಲ್ಲಿ ಗುಂಪು ಮಾಡುವುದು, ವಿಲೀನವು ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಅನಿರೀಕ್ಷಿತವಾಗಿ ಬದಲಾಯಿಸಿದೆಯೇ (ಯಾವಾಗಲೂ ವಿಲೀನದ ನಂತರ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ), ಸರಣಿ ಕಾರ್ಯಾಚರಣೆಗಳು ಮೂಲವನ್ನು ಬದಲಾಯಿಸುತ್ತವೆ.

ವಹಿವಾಟು

SQL

ಪಾಂಡಾಗಳು

ಚೆಕ್ಪಾಯಿಂಟ್

ಫಿಲ್ಟರಿಂಗ್

ಎಲ್ಲಿ

df[df.x > 5]

NULL/NaN ನಡವಳಿಕೆ

ಗುಂಪುಗಾರಿಕೆ

ಗುಂಪು

df.groupby()

ಇದು ಸರಿಯಾದ ಅಂಕಣವೇ?

ವಿಲೀನಗೊಳಿಸು

ಸೇರಿಕೊಳ್ಳಿ

df.merge()

ಸಾಲು ಎಣಿಕೆ ಬದಲಾವಣೆ

ಸಾರಾಂಶ

AVG(), SUM()

.ಮೀನ್(), .ಮೊತ್ತ()

ಯಾವ ಕಾಲಮ್ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ

ವಿಂಗಡಿಸಿ

ಆದೇಶ

.sort_values()

ದಿಕ್ಕು (ಆರೋಹಣ/ಅವರೋಹಣ)

ದ್ವಿಗುಣಗೊಳಿಸುವಿಕೆ

ಡಿಸ್ಟಿಂಕ್ಟ್

.drop_duplicates()

ಯಾವ ಅಂಕಣಗಳಲ್ಲಿ?

ಡೀಬಗ್ ಮಾಡುವುದು: AI ಜೊತೆಗೆ

ಕೋಡ್ ವಿಫಲವಾದಾಗ, AI ಅತ್ಯುತ್ತಮ ಡೀಬಗ್ ಮಾಡುವ ಪಾಲುದಾರ. ಅದಕ್ಕೆ ಸಂಪೂರ್ಣ ದೋಷ ಸಂದೇಶ ಮತ್ತು ಸಂಬಂಧಿತ ಕೋಡ್ ತುಣುಕನ್ನು ನೀಡಿ. ಆದರೆ ಎರಡು ಬಲೆಗಳ ಬಗ್ಗೆ ಎಚ್ಚರದಿಂದಿರಿ. ಮೊದಲಿಗೆ, AI ದೋಷವನ್ನು "ಮೌನಗೊಳಿಸುವ" ಪರಿಹಾರವನ್ನು ಸೂಚಿಸಬಹುದು (ಉದಾಹರಣೆಗೆ, ಎಚ್ಚರಿಕೆಗಳನ್ನು ಮರೆಮಾಡುವುದು) - ಇದು ದೋಷವನ್ನು ಸರಿಪಡಿಸುವುದಿಲ್ಲ, ಅದನ್ನು ಮರೆಮಾಡುತ್ತದೆ. ಎರಡನೆಯದಾಗಿ, ಸಮಸ್ಯೆಯನ್ನು "ಪರಿಹರಿಸುವಾಗ" AI ಕೆಲವೊಮ್ಮೆ ಮೌನವಾಗಿ ಮತ್ತೊಂದು ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ. ನಿಯಮ: ಫಿಕ್ಸ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ, ಮ್ಯೂಟ್ ಮಾಡಬೇಡಿ ಎಂದು ಪರಿಹರಿಸಿ ಮತ್ತು ಫಿಕ್ಸ್ ಮಾಡಿದ ನಂತರವೂ ಔಟ್‌ಪುಟ್ ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.

ಅರ್ಥೈಸಬಹುದಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಬೇಕು

AI ನಿಂದ ಕೋಡ್ ಅನ್ನು ಖರೀದಿಸುವಾಗ, "ಕೆಲಸ ಮಾಡುವ" ಕೋಡ್ ಮಾತ್ರವಲ್ಲದೆ, ಓದಬಹುದಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಕೇಳಿ. ನೀವು ಅಥವಾ ಸಹೋದ್ಯೋಗಿ ಆ ಕೋಡ್ ಅನ್ನು ತಿಂಗಳ ನಂತರ ತೆರೆದಾಗ, ಅದು ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, AI ಮೂರು ವಿಷಯಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಅಭ್ಯಾಸವನ್ನು ಮಾಡಿಕೊಳ್ಳಿ: ಅರ್ಥಪೂರ್ಣ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳು (orders_temiz, df2 ಅಲ್ಲ), ನಿರ್ಣಾಯಕ ಹಂತಗಳಲ್ಲಿ ಕಿರು ಕಾಮೆಂಟ್ ಲೈನ್‌ಗಳು (ಏಕೆ, ಏನು ಮಾಡಲಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುವುದು), ಮತ್ತು ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆಯ ಬದಲಿಗೆ ಹೆಸರಿಸಲಾದ ಸ್ಥಿರ (ACCEPT_ESIGI = 0.85 ಬದಲಿಗೆ 0.85 ಕೋಡ್‌ನಲ್ಲಿ ಹೂಳಲಾಗಿದೆ). ಉದ್ದವಾದ ಏಕ-ಸಾಲಿನ ಸರಪಳಿಗಳನ್ನು ಸಹ ತಪ್ಪಿಸಿ (ಒಂದು ಸಾಲಿನಲ್ಲಿ ಐದು ಕ್ರಿಯೆಗಳನ್ನು ಸಂಪರ್ಕಿಸುವುದು); ಇವು ಡೀಬಗ್ ಮಾಡುವುದನ್ನು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, AI ಸಾಮಾನ್ಯವಾಗಿ ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು "ಸ್ಮಾರ್ಟ್" ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ; ನೀವು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳಿದರೆ "ಓದಬಲ್ಲ, ಅರ್ಥೈಸಬಹುದಾದ, ನಿರ್ವಹಿಸಬಹುದಾದ", ನೀವು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಔಟ್ಪುಟ್ ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಇದು ಪುನರುತ್ಪಾದನೆಯ ಆಧಾರವಾಗಿದೆ (ಘಟಕ 10): ಅರ್ಥವಾಗದ ಕೋಡ್ ಸುರಕ್ಷಿತವಾಗಿ ಮರು-ಚಾಲನೆ ಮಾಡಲಾಗದ ಕೋಡ್ ಆಗಿದೆ.

ಮೂರು ಸಣ್ಣ ಪ್ರಕರಣಗಳು

ಪ್ರಕರಣ 1 - ಸೇರ್ಪಡೆ ಪ್ರತಿಕೃತಿ. ವಿಶ್ಲೇಷಕರು ಆರ್ಡರ್‌ಗಳನ್ನು ಉತ್ಪನ್ನ ಕೋಷ್ಟಕದೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದ್ದಾರೆ ಮತ್ತು ಒಟ್ಟು ವಹಿವಾಟು 3 ಪಟ್ಟು ಹೆಚ್ಚಾಗಿದೆ ಎಂದು ಕಂಡುಕೊಂಡರು. ಕಾರಣ: ಪ್ರತಿ ಉತ್ಪನ್ನವು ಉತ್ಪನ್ನ ಕೋಷ್ಟಕದಲ್ಲಿ ಬಹು ಸಾಲುಗಳನ್ನು (ವಿವಿಧ ಬಣ್ಣಗಳು) ಹೊಂದಿತ್ತು; JOIN ಪ್ರತಿ ಆರ್ಡರ್ ನಕಲು. AI ಯ ಕೋಡ್ "ಕೆಲಸ ಮಾಡುತ್ತಿದೆ", ಆದರೆ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯು 240 ಸಾವಿರದಿಂದ 690 ಸಾವಿರಕ್ಕೆ ಜಿಗಿದಿದೆ. ಪಾಠ: ವಿಲೀನ/ಸೇರಿದ ನಂತರ ಯಾವಾಗಲೂ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ.

ಪ್ರಕರಣ 2 - ಫಿಟ್ಟಿಂಗ್ ಕಾರ್ಯ. ಅವರು AI df.groupby('x').summarize() ಅನ್ನು ಇಂಟರ್ನ್‌ಗೆ ಸೂಚಿಸಿದರು; ಪಾಂಡಾಗಳಲ್ಲಿ ಅಂತಹ ವಿಧಾನವಿಲ್ಲ (ಅಲ್ಲಿ .agg()). ಕೋಡ್ ಕೆಲಸ ಮಾಡಲಿಲ್ಲ, ಇಂಟರ್ನ್ 20 ನಿಮಿಷಗಳ ಕಾಲ ಕಳೆದುಹೋಯಿತು. ಪಾಠ: ಡಾಕ್‌ನಿಂದ ನೀವು ಗುರುತಿಸದ ಕಾರ್ಯವನ್ನು ಪರಿಶೀಲಿಸಿ; AI ವಿಧಾನಗಳನ್ನು ರಚಿಸಬಹುದು.

ಪ್ರಕರಣ 3 - ಇಳುವರಿ ಕುಸಿತ. ಒಂದು ಕೋಡ್ ಪ್ರತಿ ಸಾಲಿಗೆ ಅನ್ವಯವಾಗುವ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಪ್ರಶ್ನಿಸುತ್ತಿದೆ; ಇದು 5,000 ಲೈನ್‌ಗಳಲ್ಲಿ ಓಡಿತು, 4 ಮಿಲಿಯನ್ ಲೈನ್‌ಗಳಲ್ಲಿ 9 ಗಂಟೆಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು ಮತ್ತು ನಿಲ್ಲಿಸಿತು. AI ವೆಕ್ಟರೈಸ್ಡ್ (ಬ್ಯಾಚ್) ಪರಿಹಾರವನ್ನು ಸೂಚಿಸಿದಾಗ, ಸಮಯವನ್ನು 40 ಸೆಕೆಂಡುಗಳಿಗೆ ಇಳಿಸಲಾಯಿತು. ಪಾಠ: ಸಣ್ಣ ಡೇಟಾದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕೋಡ್ ದೊಡ್ಡ ಡೇಟಾದಲ್ಲಿ ಕ್ರ್ಯಾಶ್ ಆಗಬಹುದು; ದಕ್ಷತೆಯನ್ನು ಪರಿಗಣಿಸಿ.

ನಾಲ್ಕು ನಕಲಿಸಬಹುದಾದ ಟೆಂಪ್ಲೇಟ್‌ಗಳು

1) ಸ್ಕೀಮಾದೊಂದಿಗೆ SQL ಅನ್ನು ವಿನಂತಿಸಲಾಗುತ್ತಿದೆ:

ನಿಮ್ಮ ಪಾತ್ರ: SQL ಸಹಾಯಕ (PostgreSQL). ಕೋಷ್ಟಕಗಳು:- ಆರ್ಡರ್‌ಗಳು(ಐಡಿ, ಕಸ್ಟಮರ್_ಐಡಿ, ದಿನಾಂಕ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್, ಮೊತ್ತ ಸಂಖ್ಯಾತ್ಮಕ)- ಗ್ರಾಹಕರು(ಐಡಿ, ಸಿಟಿ ಟೆಕ್ಸ್ಟ್)ಕಾರ್ಯ: 2024 ರಲ್ಲಿ ಪ್ರತಿ ನಗರಕ್ಕೆ ಒಟ್ಟು ವಹಿವಾಟು ಮತ್ತು ಆರ್ಡರ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಅವರೋಹಣ ಕ್ರಮದಲ್ಲಿ ವಹಿವಾಟು ಮೂಲಕ ವಿಂಗಡಿಸಿ. ನೀವು NULL ನಗರಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತೀರಿ ಎಂಬುದನ್ನು ವಿವರಿಸಿ. ನಾನು ಮೊದಲು LIMIT ಜೊತೆಗೆ ಪ್ರಶ್ನೆಯನ್ನು ಪರೀಕ್ಷಿಸುತ್ತೇನೆ; ಪೀಳಿಗೆಯನ್ನು ನವೀಕರಿಸಿ/ಅಳಿಸಿ.

2) ಚೆಕ್‌ಪಾಯಿಂಟ್‌ನೊಂದಿಗೆ ಪಾಂಡಾಗಳ ಪ್ರಕ್ರಿಯೆ:

ನಾನು DataFrames df (ಆರ್ಡರ್‌ಗಳು) ಮತ್ತು df_customers (ಗ್ರಾಹಕರು) ಹೊಂದಿದ್ದೇನೆ. ಪ್ರತಿ ನಗರಕ್ಕೆ ಸರಾಸರಿ ಮೊತ್ತವನ್ನು ಲೆಕ್ಕಹಾಕಿ. ಪ್ರಮುಖ: ವಿಲೀನದ ಮೊದಲು ಮತ್ತು ನಂತರ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮುದ್ರಿಸಿ ಇದರಿಂದ ನಾನು ನಕಲು ಇದೆಯೇ ಎಂದು ನೋಡಬಹುದು. ನೀವು ಯಾವ ಕಾಲಮ್‌ನಲ್ಲಿ ವಿಲೀನಗೊಂಡಿದ್ದೀರಿ ಮತ್ತು ನೀವು ಒಳ/ಎಡವನ್ನು ಏಕೆ ಆರಿಸಿದ್ದೀರಿ ಎಂಬುದನ್ನು ವಿವರಿಸಿ.

3) ಕೋಡ್ ವಿವರಣೆ ಮತ್ತು ಪರಿಶೀಲನೆ:

ಕೆಳಗಿನ ಪಾಂಡಾಗಳ ಕೋಡ್ ಲೈನ್ ಅನ್ನು ಸಾಲಿನ ಮೂಲಕ ವಿವರಿಸಿ: ಪ್ರತಿ ಸಾಲು ಏನು ಮಾಡುತ್ತದೆ, ಅದು ಯಾವ ಊಹೆಗಳನ್ನು ಮಾಡುತ್ತದೆ, ಯಾವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅದು ತಪ್ಪು ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡಬಹುದು? ನಾನು ಮಿಠಾಯಿ ಕಾರ್ಯವನ್ನು ಬಳಸಿದ್ದರೆ ನನಗೆ ತಿಳಿಸಿ. ಕೋಡ್: [ಅಂಟಿಸಿ]

4) ಡೀಬಗ್ ಮಾಡುವುದು:

ಈ ಕೋಡ್ ಈ ದೋಷವನ್ನು ನೀಡುತ್ತದೆ. ಪೂರ್ಣ ದೋಷ ಸಂದೇಶ: [ಅಂಟಿಸಿ]. ಕೋಡ್: [ಅಂಟಿಸಿ]. ದೋಷದ ಮೂಲ ಕಾರಣವನ್ನು ವಿವರಿಸಿ ಮತ್ತು ಅದನ್ನು ಸರಿಪಡಿಸಿ. ಸಮಸ್ಯೆಯನ್ನು ನಿಜವಾಗಿ ಪರಿಹರಿಸುವ ಮೂಲಕ ಅದನ್ನು ಸರಿಪಡಿಸಿ, ಎಚ್ಚರಿಕೆಯನ್ನು ಮೌನಗೊಳಿಸುವ ಮೂಲಕ ಅಲ್ಲ. ಫಿಕ್ಸ್ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಬದಲಾಯಿಸಿದೆಯೇ ಎಂಬುದನ್ನು ಸಹ ಸೂಚಿಸಿ.

ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್ / ಬಲವಾದ ಪ್ರಾಂಪ್ಟ್

ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್:

ಪ್ರತಿ ನಗರಕ್ಕೆ ನನಗೆ ಮಾರಾಟವನ್ನು ನೀಡುವ ಪ್ರಶ್ನೆಯನ್ನು ಬರೆಯಿರಿ.

ಟೇಬಲ್ ಹೆಸರುಗಳು, ಕಾಲಮ್‌ಗಳು, ಡೇಟಾಬೇಸ್ ಪ್ರಕಾರ, NULL ನಡವಳಿಕೆ ಅಸ್ಪಷ್ಟವಾಗಿದೆ. AI ಸಾಮಾನ್ಯವಾಗಿದೆ, ಇದು ಬಹುಶಃ ನಿಮ್ಮ ಟೇಬಲ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗದ ಪ್ರಶ್ನೆಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಶಕ್ತಿಯುತ ಪ್ರಾಂಪ್ಟ್:

ನಿಮ್ಮ ಪಾತ್ರ: SQL ಸಹಾಯಕ (MySQL 8). ಕೋಷ್ಟಕ: ಮಾರಾಟ (ಐಡಿ, ನಗರ ವರ್ಚಾರ್, ಮೊತ್ತ ದಶಮಾಂಶ, ದಿನಾಂಕ ದಿನಾಂಕ). ಕಾರ್ಯ: 2024 ರ ಒಟ್ಟು ಮತ್ತು ಸರಾಸರಿ ಮೊತ್ತವನ್ನು ಪಡೆಯಿರಿ, ಪ್ರತಿ ನಗರಕ್ಕೆ ಆರ್ಡರ್‌ಗಳ ಸಂಖ್ಯೆ; ಒಟ್ಟು ಮೊತ್ತದಿಂದ ವಿಂಗಡಿಸಿ ಕಡಿಮೆಯಾಗುತ್ತದೆ; 100 ಕ್ಕೂ ಹೆಚ್ಚು ಆರ್ಡರ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ನಗರಗಳನ್ನು ಮಾತ್ರ ತೋರಿಸಿ (ಹೊಂದಿದೆ). NULL ನಗರವನ್ನು ಹೊರತುಪಡಿಸಿ. ಪ್ರಶ್ನೆಯನ್ನು ವಿವರಿಸಿ; ನಾನು LIMIT ಜೊತೆಗೆ ಪರೀಕ್ಷೆ ಮಾಡುತ್ತೇನೆ.

ಇಲ್ಲಿ ಡೇಟಾಬೇಸ್, ಸ್ಕೀಮಾ, ಫಿಲ್ಟರ್, ವಿಂಗಡಣೆ ಮತ್ತು NULL ನಿಯಮವು ಸ್ಪಷ್ಟವಾಗಿದೆ.

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• ಕೋಡ್ ಅನ್ನು ಓದದೆ ರನ್ ಮಾಡುವುದು. ವರ್ಕಿಂಗ್ ಕೋಡ್ ಸರಿಯಾದ ಕೋಡ್ ಅಲ್ಲ; ತಪ್ಪು ಕಾಲಮ್ ಅನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುವ ಕೋಡ್ ಸಹ ದೋಷಗಳಿಲ್ಲದೆ ಚಲಿಸುತ್ತದೆ.
• ವಿಲೀನ/ಸೇರಿದ ನಂತರ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತಿಲ್ಲ. ತಪ್ಪಾದ ಕೀ ಮೌನವಾಗಿ ಸಾಲುಗಳನ್ನು ನಕಲು ಮಾಡುತ್ತದೆ ಮತ್ತು ಮೊತ್ತವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.
• ಅಳವಡಿಸುವ ಕಾರ್ಯವನ್ನು ಪರಿಶೀಲಿಸುತ್ತಿಲ್ಲ. AI ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ವಿಧಾನಗಳನ್ನು ಸೂಚಿಸಬಹುದು; ನೀವು ಅದನ್ನು ಗುರುತಿಸುವುದಿಲ್ಲ ಎಂದು ಡಾಕ್ಯುಮೆಂಟ್‌ನಿಂದ ದೃಢೀಕರಿಸಿ.
• ದಕ್ಷತೆಯ ಬಗ್ಗೆ ಯೋಚಿಸುವುದಿಲ್ಲ. ಲಕ್ಷಾಂತರ ಸಾಲುಗಳಲ್ಲಿ ಸಣ್ಣ ಡೇಟಾ ಕ್ರ್ಯಾಶ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಅನ್ವಯಿಸು/ಲೂಪ್; ವೆಕ್ಟರೈಸ್.
• ಉತ್ಪಾದನಾ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ರನ್ ಮಾಡಿ. ವಿಶೇಷವಾಗಿ ಎಲ್ಲಿ ಅಥವಾ ಪರೀಕ್ಷೆ ಇಲ್ಲದೆ ಅಪ್‌ಡೇಟ್/ಡಿಲೀಟ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವುದು ಹಾನಿಕಾರಕವಾಗಿದೆ.

ಸಲಹೆ: AI ನಿಂದ ನೀವು ಸ್ವೀಕರಿಸುವ ಪ್ರತಿಯೊಂದು ಕೋಡ್‌ಗೆ "ಮೌಲ್ಯಮಾಪನ ರೇಖೆ" ಸೇರಿಸುವ ಅಭ್ಯಾಸವನ್ನು ಪಡೆಯಿರಿ: ಪೂರ್ವ ಮತ್ತು ನಂತರದ ಪ್ರಕ್ರಿಯೆಯ ಸಾಲುಗಳ ಸಂಖ್ಯೆ, ಕೆಲವು ಮಾದರಿ ಸಾಲುಗಳು ಮತ್ತು ಕೈಯಿಂದ ನಿರ್ಣಾಯಕ ಮೊತ್ತ. ಈ ಮೂರು ತಪಾಸಣೆಗಳು ಹೆಚ್ಚಿನ ಮೂಕ ತರ್ಕ ದೋಷಗಳನ್ನು ಹಿಡಿಯುತ್ತವೆ.

ಸಾರಾಂಶದಲ್ಲಿ

AI ಶಕ್ತಿಯುತ ಪಾಲುದಾರರಾಗಿದ್ದು ಅದು ತ್ವರಿತವಾಗಿ SQL ಮತ್ತು ಪಾಂಡಾಸ್ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಆದರೆ ಇದು ಕುರುಡು ಅಧಿಕಾರವಲ್ಲ. ಅವನಿಗೆ ಯೋಜನೆ ಮತ್ತು ಉದ್ದೇಶವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನೀಡಿ; ನೀವೇ ಬರೆದಂತೆ ಅದು ಉತ್ಪಾದಿಸುವ ಕೋಡ್ ಅನ್ನು ಓದಿ; ವಿಲೀನ/ಸೇರುವಿಕೆಯ ನಂತರ ಸಾಲುಗಳ ಸಂಖ್ಯೆ, ಅಳವಡಿಸುವ ಕಾರ್ಯಗಳು ಮತ್ತು ಥ್ರೋಪುಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ; ಉತ್ಪಾದನಾ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಅದನ್ನು ಪರೀಕ್ಷಿಸದೆ ಅದನ್ನು ಚಲಾಯಿಸಬೇಡಿ. ಡೀಬಗ್ ಮಾಡುವಾಗ, ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿರಿ, ಮೌನವಾಗಿರಬಾರದು. ಕೆಲಸ ಮಾಡುವ ಕೋಡ್ ಸರಿಯಾದ ಕೋಡ್ ಅಲ್ಲ; ನೀವು ಮಾತ್ರ ನಿಖರತೆಯನ್ನು ಖಾತರಿಪಡಿಸಬಹುದು.

ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯ

ವಿಶ್ಲೇಷಣಾ ಪ್ರಶ್ನೆಯನ್ನು ಆರಿಸಿ (ಉದಾ. "ಪ್ರತಿ ಚಾನೆಲ್‌ಗೆ ಮಾಸಿಕ ವಹಿವಾಟು") ಮತ್ತು SQL ಮತ್ತು ಪಾಂಡಾಗಳೆರಡರಲ್ಲೂ AI ನಿಂದ ಕೋಡ್ ವಿನಂತಿಸಿ. ಎರಡೂ ಕೋಡ್ ಸಾಲುಗಳನ್ನು ಸಾಲಿನ ಮೂಲಕ ಓದಿ, ವಿಲೀನ/ಸೇರುವಿಕೆಯ ನಂತರ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಕನಿಷ್ಠ ಒಂದು ನಿರ್ಣಾಯಕ ಮೊತ್ತವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಪರಿಶೀಲಿಸಿ. ಎರಡು ಕೋಡ್‌ಗಳು ಒಂದೇ ಫಲಿತಾಂಶವನ್ನು ನೀಡುತ್ತವೆಯೇ ಎಂದು ಹೋಲಿಕೆ ಮಾಡಿ; ವಿಭಿನ್ನವಾಗಿದ್ದರೆ, ಏಕೆ ಎಂದು ಕಂಡುಹಿಡಿಯಿರಿ.

ಪರಿಶೀಲನಾಪಟ್ಟಿ

• [ ] ನಾನು ಟೇಬಲ್/ಸ್ಕೀಮಾ ಮತ್ತು ಉದ್ದೇಶವನ್ನು AI ಗೆ ಸ್ಪಷ್ಟವಾಗಿ ನೀಡಿದ್ದೇನೆಯೇ?
• [ ] ನಾನು ಸಾಲಿನಿಂದ ಅದು ಉತ್ಪಾದಿಸಿದ ಕೋಡ್ ಅನ್ನು ಓದಿ ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೇನೆಯೇ?
• [ ] ವಿಲೀನ/ಸೇರುವಿಕೆಯ ನಂತರ ನಾನು ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿದ್ದೇನೆಯೇ?
• [ ] ಡಾಕ್ಯುಮೆಂಟೇಶನ್‌ನಿಂದ ನಾನು ಗುರುತಿಸದ ಕಾರ್ಯಗಳನ್ನು ನಾನು ಪರಿಶೀಲಿಸಿದ್ದೇನೆಯೇ?
• [ ] ನಾನು ಮೊದಲು ಸುರಕ್ಷಿತ/ಸಣ್ಣ ಡೇಟಾದಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಿದ್ದೇನೆಯೇ ಮತ್ತು ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ಅಲ್ಲವೇ?