ಸರಳ ರೇಖಾತ್ಮಕ ಹಿಂಜರಿತ ಸಮೀಕರಣವನ್ನು ಪರಿಹರಿಸುವುದು

ಸರಳ (ಜೋಡಿಯಾಗಿರುವ) ಹಿಂಜರಿತ ರೇಖೆಯ ಗಣಿತದ ಸಮೀಕರಣವನ್ನು ನಿರ್ಧರಿಸಲು ಲೇಖನವು ಹಲವಾರು ಮಾರ್ಗಗಳನ್ನು ಚರ್ಚಿಸುತ್ತದೆ.

ಇಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ಸಮೀಕರಣವನ್ನು ಪರಿಹರಿಸುವ ಎಲ್ಲಾ ವಿಧಾನಗಳು ಕನಿಷ್ಠ ಚೌಕಗಳ ವಿಧಾನವನ್ನು ಆಧರಿಸಿವೆ. ವಿಧಾನಗಳನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಸೂಚಿಸೋಣ:

• ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರ
• ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್
• ಸ್ಟೊಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣ

ಸರಳ ರೇಖೆಯ ಸಮೀಕರಣವನ್ನು ಪರಿಹರಿಸುವ ಪ್ರತಿಯೊಂದು ವಿಧಾನಕ್ಕೂ, ಲೇಖನವು ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇವುಗಳನ್ನು ಮುಖ್ಯವಾಗಿ ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸದೆ ಬರೆಯಲಾದವುಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ. ನಂಬಿ ಮತ್ತು ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಬಳಸುವವರು ನಂಬಿ. ಕೌಶಲ್ಯಪೂರ್ಣ ಬಳಕೆ ಎಂದು ನಂಬಲಾಗಿದೆ ನಂಬಿ ಕಂಪ್ಯೂಟಿಂಗ್ ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಲೇಖನದಲ್ಲಿ ನೀಡಲಾದ ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಭಾಷೆಯಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಪೈಥಾನ್ 2.7 ಬಳಸಲಾಗುತ್ತಿದೆ ಜುಪಿಟರ್ ನೋಟ್ಬುಕ್. ಮಾದರಿ ಡೇಟಾದೊಂದಿಗೆ ಮೂಲ ಕೋಡ್ ಮತ್ತು ಫೈಲ್ ಅನ್ನು ಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ ಗಿಥಬ್

ಲೇಖನವು ಆರಂಭಿಕರಿಗಾಗಿ ಮತ್ತು ಈಗಾಗಲೇ ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯಲ್ಲಿ ಬಹಳ ವಿಶಾಲವಾದ ವಿಭಾಗದ ಅಧ್ಯಯನವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸಿದವರಿಗೆ ಹೆಚ್ಚು ಗುರಿಯನ್ನು ಹೊಂದಿದೆ - ಯಂತ್ರ ಕಲಿಕೆ.

ವಸ್ತುವನ್ನು ವಿವರಿಸಲು, ನಾವು ಸರಳವಾದ ಉದಾಹರಣೆಯನ್ನು ಬಳಸುತ್ತೇವೆ.

ಉದಾಹರಣೆ ಪರಿಸ್ಥಿತಿಗಳು

ಅವಲಂಬನೆಯನ್ನು ನಿರೂಪಿಸುವ ಐದು ಮೌಲ್ಯಗಳನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ Y ರಿಂದ X (ಕೋಷ್ಟಕ ಸಂಖ್ಯೆ 1):

ಕೋಷ್ಟಕ ಸಂಖ್ಯೆ 1 "ಉದಾಹರಣೆ ಷರತ್ತುಗಳು"

ಮೌಲ್ಯಗಳು ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ ವರ್ಷದ ತಿಂಗಳು, ಮತ್ತು - ಈ ತಿಂಗಳ ಆದಾಯ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಆದಾಯವು ವರ್ಷದ ತಿಂಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ, ಮತ್ತು - ಆದಾಯವನ್ನು ಅವಲಂಬಿಸಿರುವ ಏಕೈಕ ಚಿಹ್ನೆ.

ಉದಾಹರಣೆ ಹೀಗಿದೆ, ವರ್ಷದ ತಿಂಗಳ ಆದಾಯದ ಷರತ್ತುಬದ್ಧ ಅವಲಂಬನೆಯ ದೃಷ್ಟಿಕೋನದಿಂದ ಮತ್ತು ಮೌಲ್ಯಗಳ ಸಂಖ್ಯೆಯ ದೃಷ್ಟಿಕೋನದಿಂದ - ಅವುಗಳಲ್ಲಿ ಕೆಲವೇ ಇವೆ. ಆದಾಗ್ಯೂ, ಅಂತಹ ಸರಳೀಕರಣವು ಅವರು ಹೇಳಿದಂತೆ, ಯಾವಾಗಲೂ ಸುಲಭವಾಗಿ ವಿವರಿಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ, ಆರಂಭಿಕರು ಸಂಯೋಜಿಸುವ ವಸ್ತು. ಮತ್ತು ಸಂಖ್ಯೆಗಳ ಸರಳತೆಯು ಗಮನಾರ್ಹ ಕಾರ್ಮಿಕ ವೆಚ್ಚವಿಲ್ಲದೆ ಕಾಗದದ ಮೇಲೆ ಉದಾಹರಣೆಯನ್ನು ಪರಿಹರಿಸಲು ಬಯಸುವವರಿಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಯಲ್ಲಿ ನೀಡಲಾದ ಅವಲಂಬನೆಯನ್ನು ರೂಪದ ಸರಳ (ಜೋಡಿಯಾಗಿರುವ) ರಿಗ್ರೆಷನ್ ರೇಖೆಯ ಗಣಿತದ ಸಮೀಕರಣದಿಂದ ಚೆನ್ನಾಗಿ ಅಂದಾಜಿಸಬಹುದು ಎಂದು ನಾವು ಭಾವಿಸೋಣ:

ಅಲ್ಲಿ ಆದಾಯವನ್ನು ಪಡೆದ ತಿಂಗಳು, - ತಿಂಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಆದಾಯ, и ಅಂದಾಜು ರೇಖೆಯ ಹಿಂಜರಿತ ಗುಣಾಂಕಗಳಾಗಿವೆ.

ಗುಣಾಂಕ ಎಂಬುದನ್ನು ಗಮನಿಸಿ ಸಾಮಾನ್ಯವಾಗಿ ಅಂದಾಜು ರೇಖೆಯ ಇಳಿಜಾರು ಅಥವಾ ಗ್ರೇಡಿಯಂಟ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ; ಮೊತ್ತವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಅದು ಬದಲಾದಾಗ .

ನಿಸ್ಸಂಶಯವಾಗಿ, ಉದಾಹರಣೆಯಲ್ಲಿ ನಮ್ಮ ಕಾರ್ಯವು ಸಮೀಕರಣದಲ್ಲಿ ಅಂತಹ ಗುಣಾಂಕಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು и , ನಿಜವಾದ ಉತ್ತರಗಳಿಂದ ತಿಂಗಳಿಗೆ ನಮ್ಮ ಲೆಕ್ಕಾಚಾರದ ಆದಾಯದ ಮೌಲ್ಯಗಳ ವಿಚಲನಗಳು, ಅಂದರೆ. ಮಾದರಿಯಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾದ ಮೌಲ್ಯಗಳು ಕಡಿಮೆ ಇರುತ್ತದೆ.

ಕಡಿಮೆ ಚೌಕ ವಿಧಾನ

ಕನಿಷ್ಠ ಚೌಕಗಳ ವಿಧಾನದ ಪ್ರಕಾರ, ವಿಚಲನವನ್ನು ವರ್ಗೀಕರಿಸುವ ಮೂಲಕ ಲೆಕ್ಕ ಹಾಕಬೇಕು. ವಿರುದ್ಧ ಚಿಹ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ವಿಚಲನಗಳ ಪರಸ್ಪರ ರದ್ದತಿಯನ್ನು ತಪ್ಪಿಸಲು ಈ ತಂತ್ರವು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಒಂದು ಸಂದರ್ಭದಲ್ಲಿ, ವಿಚಲನ +5 (ಜೊತೆಗೆ ಐದು), ಮತ್ತು ಇನ್ನೊಂದರಲ್ಲಿ -5 (ಮೈನಸ್ ಐದು), ನಂತರ ವಿಚಲನಗಳ ಮೊತ್ತವು ಪರಸ್ಪರ ರದ್ದುಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಮೊತ್ತವು 0 (ಶೂನ್ಯ). ವಿಚಲನವನ್ನು ವರ್ಗೀಕರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದರೆ ಮಾಡ್ಯುಲಸ್ನ ಆಸ್ತಿಯನ್ನು ಬಳಸಲು ಮತ್ತು ನಂತರ ಎಲ್ಲಾ ವಿಚಲನಗಳು ಧನಾತ್ಮಕವಾಗಿರುತ್ತವೆ ಮತ್ತು ಸಂಗ್ರಹಗೊಳ್ಳುತ್ತವೆ. ನಾವು ಈ ಹಂತದಲ್ಲಿ ವಿವರವಾಗಿ ವಾಸಿಸುವುದಿಲ್ಲ, ಆದರೆ ಲೆಕ್ಕಾಚಾರಗಳ ಅನುಕೂಲಕ್ಕಾಗಿ, ವಿಚಲನವನ್ನು ವರ್ಗೀಕರಿಸುವುದು ವಾಡಿಕೆ ಎಂದು ಸರಳವಾಗಿ ಸೂಚಿಸುತ್ತೇವೆ.

ಈ ಸೂತ್ರವು ಹೇಗೆ ಕಾಣುತ್ತದೆ ಅದರೊಂದಿಗೆ ನಾವು ವರ್ಗದ ವಿಚಲನಗಳ (ದೋಷಗಳು) ಕನಿಷ್ಠ ಮೊತ್ತವನ್ನು ನಿರ್ಧರಿಸುತ್ತೇವೆ:

ಅಲ್ಲಿ ನಿಜವಾದ ಉತ್ತರಗಳ ಅಂದಾಜು ಕಾರ್ಯವಾಗಿದೆ (ಅಂದರೆ, ನಾವು ಲೆಕ್ಕ ಹಾಕಿದ ಆದಾಯ),

ನಿಜವಾದ ಉತ್ತರಗಳು (ಮಾದರಿಯಲ್ಲಿ ಒದಗಿಸಲಾದ ಆದಾಯ),

ಮಾದರಿ ಸೂಚ್ಯಂಕವಾಗಿದೆ (ವಿಚಲನವನ್ನು ನಿರ್ಧರಿಸುವ ತಿಂಗಳ ಸಂಖ್ಯೆ)

ಕಾರ್ಯವನ್ನು ಪ್ರತ್ಯೇಕಿಸೋಣ, ಭಾಗಶಃ ಭೇದಾತ್ಮಕ ಸಮೀಕರಣಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ ಮತ್ತು ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರಕ್ಕೆ ತೆರಳಲು ಸಿದ್ಧರಾಗಿರಿ. ಆದರೆ ಮೊದಲು, ವ್ಯತ್ಯಾಸವೇನು ಎಂಬುದರ ಕುರಿತು ಸಣ್ಣ ವಿಹಾರವನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ ಮತ್ತು ಉತ್ಪನ್ನದ ಜ್ಯಾಮಿತೀಯ ಅರ್ಥವನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳೋಣ.

ವ್ಯತ್ಯಾಸ

ವ್ಯತ್ಯಾಸವು ಕ್ರಿಯೆಯ ವ್ಯುತ್ಪನ್ನವನ್ನು ಕಂಡುಹಿಡಿಯುವ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ.

ಉತ್ಪನ್ನವನ್ನು ಯಾವುದಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ? ಕ್ರಿಯೆಯ ವ್ಯುತ್ಪನ್ನವು ಕಾರ್ಯದ ಬದಲಾವಣೆಯ ದರವನ್ನು ನಿರೂಪಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ದಿಕ್ಕನ್ನು ನಮಗೆ ತಿಳಿಸುತ್ತದೆ. ಒಂದು ನಿರ್ದಿಷ್ಟ ಹಂತದಲ್ಲಿ ವ್ಯುತ್ಪನ್ನವು ಧನಾತ್ಮಕವಾಗಿದ್ದರೆ, ಕಾರ್ಯವು ಹೆಚ್ಚಾಗುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ, ಕಾರ್ಯವು ಕಡಿಮೆಯಾಗುತ್ತದೆ. ಮತ್ತು ಸಂಪೂರ್ಣ ವ್ಯುತ್ಪನ್ನದ ಹೆಚ್ಚಿನ ಮೌಲ್ಯವು, ಕಾರ್ಯದ ಮೌಲ್ಯಗಳ ಬದಲಾವಣೆಯ ದರವು ಹೆಚ್ಚಿನದಾಗಿರುತ್ತದೆ, ಜೊತೆಗೆ ಫಂಕ್ಷನ್ ಗ್ರಾಫ್ನ ಇಳಿಜಾರು ಹೆಚ್ಚು.

ಉದಾಹರಣೆಗೆ, ಕಾರ್ಟೇಶಿಯನ್ ನಿರ್ದೇಶಾಂಕ ವ್ಯವಸ್ಥೆಯ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ, ಪಾಯಿಂಟ್ M(0,0) ನಲ್ಲಿನ ಉತ್ಪನ್ನದ ಮೌಲ್ಯವು ಸಮಾನವಾಗಿರುತ್ತದೆ 25 + ಒಂದು ನಿರ್ದಿಷ್ಟ ಹಂತದಲ್ಲಿ, ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಿದಾಗ ಎಂದರ್ಥ ಸಾಂಪ್ರದಾಯಿಕ ಘಟಕದಿಂದ ಬಲಕ್ಕೆ, ಮೌಲ್ಯ 25 ಸಾಂಪ್ರದಾಯಿಕ ಘಟಕಗಳಿಂದ ಹೆಚ್ಚಾಗುತ್ತದೆ. ಗ್ರಾಫ್‌ನಲ್ಲಿ ಇದು ಮೌಲ್ಯಗಳಲ್ಲಿ ಸಾಕಷ್ಟು ಕಡಿದಾದ ಏರಿಕೆ ತೋರುತ್ತಿದೆ ನಿರ್ದಿಷ್ಟ ಬಿಂದುವಿನಿಂದ.

ಇನ್ನೊಂದು ಉದಾಹರಣೆ. ವ್ಯುತ್ಪನ್ನ ಮೌಲ್ಯವು ಸಮಾನವಾಗಿರುತ್ತದೆ -0,1 ಸ್ಥಳಾಂತರಗೊಂಡಾಗ ಎಂದರ್ಥ ಒಂದು ಸಾಂಪ್ರದಾಯಿಕ ಘಟಕಕ್ಕೆ, ಮೌಲ್ಯ ಕೇವಲ 0,1 ಸಾಂಪ್ರದಾಯಿಕ ಘಟಕದಿಂದ ಕಡಿಮೆಯಾಗುತ್ತದೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಕಾರ್ಯದ ಗ್ರಾಫ್ನಲ್ಲಿ, ನಾವು ಕೇವಲ ಗಮನಿಸಬಹುದಾದ ಕೆಳಮುಖ ಇಳಿಜಾರನ್ನು ಗಮನಿಸಬಹುದು. ಪರ್ವತದೊಂದಿಗೆ ಸಾದೃಶ್ಯವನ್ನು ಚಿತ್ರಿಸುವುದು, ನಾವು ಪರ್ವತದಿಂದ ಸೌಮ್ಯವಾದ ಇಳಿಜಾರನ್ನು ನಿಧಾನವಾಗಿ ಇಳಿಯುತ್ತಿರುವಂತೆ ತೋರುತ್ತದೆ, ಹಿಂದಿನ ಉದಾಹರಣೆಗಿಂತ ಭಿನ್ನವಾಗಿ, ನಾವು ತುಂಬಾ ಕಡಿದಾದ ಶಿಖರಗಳನ್ನು ಏರಬೇಕಾಗಿತ್ತು :)

ಹೀಗಾಗಿ, ಕಾರ್ಯವನ್ನು ಪ್ರತ್ಯೇಕಿಸಿದ ನಂತರ ಆಡ್ಸ್ ಮೂಲಕ и , ನಾವು 1 ನೇ ಕ್ರಮಾಂಕದ ಭಾಗಶಃ ಭೇದಾತ್ಮಕ ಸಮೀಕರಣಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ಸಮೀಕರಣಗಳನ್ನು ನಿರ್ಧರಿಸಿದ ನಂತರ, ನಾವು ಎರಡು ಸಮೀಕರಣಗಳ ವ್ಯವಸ್ಥೆಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ, ಅದನ್ನು ಪರಿಹರಿಸುವ ಮೂಲಕ ನಾವು ಗುಣಾಂಕಗಳ ಅಂತಹ ಮೌಲ್ಯಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. и , ಇದಕ್ಕಾಗಿ ನಿರ್ದಿಷ್ಟ ಬಿಂದುಗಳಲ್ಲಿನ ಅನುಗುಣವಾದ ಉತ್ಪನ್ನಗಳ ಮೌಲ್ಯಗಳು ಬಹಳ ಕಡಿಮೆ ಪ್ರಮಾಣದಲ್ಲಿ ಬದಲಾಗುತ್ತವೆ ಮತ್ತು ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರದ ಸಂದರ್ಭದಲ್ಲಿ ಬದಲಾಗುವುದಿಲ್ಲ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಕಂಡುಬರುವ ಗುಣಾಂಕಗಳಲ್ಲಿನ ದೋಷ ಕಾರ್ಯವು ಕನಿಷ್ಠವನ್ನು ತಲುಪುತ್ತದೆ, ಏಕೆಂದರೆ ಈ ಬಿಂದುಗಳಲ್ಲಿನ ಭಾಗಶಃ ಉತ್ಪನ್ನಗಳ ಮೌಲ್ಯಗಳು ಶೂನ್ಯಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ.

ಆದ್ದರಿಂದ, ವಿಭಿನ್ನತೆಯ ನಿಯಮಗಳ ಪ್ರಕಾರ, ಗುಣಾಂಕಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ 1 ನೇ ಕ್ರಮಾಂಕದ ಭಾಗಶಃ ಉತ್ಪನ್ನ ಸಮೀಕರಣ ರೂಪವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ:

ಸಂಬಂಧಿಸಿದಂತೆ 1 ನೇ ಕ್ರಮಾಂಕದ ಭಾಗಶಃ ಉತ್ಪನ್ನ ಸಮೀಕರಣ ರೂಪವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ:

ಪರಿಣಾಮವಾಗಿ, ನಾವು ಸಾಕಷ್ಟು ಸರಳವಾದ ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರವನ್ನು ಹೊಂದಿರುವ ಸಮೀಕರಣಗಳ ವ್ಯವಸ್ಥೆಯನ್ನು ಸ್ವೀಕರಿಸಿದ್ದೇವೆ:

ಪ್ರಾರಂಭ{ಸಮೀಕರಣ*}
ಪ್ರಾರಂಭ{ಪ್ರಕರಣಗಳು}
na + bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i = 0

sumlimits_{i=1}^nx_i(a +bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i) = 0
ಅಂತ್ಯ{ಪ್ರಕರಣಗಳು}
ಅಂತ್ಯ{ಸಮೀಕರಣ*}

ಸಮೀಕರಣವನ್ನು ಪರಿಹರಿಸುವ ಮೊದಲು, ಪೂರ್ವ ಲೋಡ್ ಮಾಡೋಣ, ಲೋಡಿಂಗ್ ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಡೇಟಾವನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡೋಣ.

ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ ಮತ್ತು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರಕ್ಕಾಗಿ ಮತ್ತು ತರುವಾಯ ಗ್ರೇಡಿಯಂಟ್ ಮತ್ತು ಸ್ಟೋಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣಕ್ಕಾಗಿ, ನಾವು ಕೋಡ್ ಅನ್ನು ಎರಡು ಮಾರ್ಪಾಡುಗಳಲ್ಲಿ ಬಳಸುತ್ತೇವೆ ಎಂದು ಗಮನಿಸಬೇಕು: ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸುವುದು ನಂಬಿ ಮತ್ತು ಅದನ್ನು ಬಳಸದೆಯೇ, ನಮಗೆ ಸೂಕ್ತವಾದ ಡೇಟಾ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅಗತ್ಯವಿರುತ್ತದೆ (ಕೋಡ್ ನೋಡಿ).

ಡೇಟಾ ಲೋಡ್ ಮತ್ತು ಪ್ರಕ್ರಿಯೆ ಕೋಡ್

# импортируем все нужные нам библиотеки
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import math
import pylab as pl
import random

# графики отобразим в Jupyter
%matplotlib inline

# укажем размер графиков
from pylab import rcParams
rcParams['figure.figsize'] = 12, 6

# отключим предупреждения Anaconda
import warnings
warnings.simplefilter('ignore')

# загрузим значения
table_zero = pd.read_csv('data_example.txt', header=0, sep='t')

# посмотрим информацию о таблице и на саму таблицу
print table_zero.info()
print '********************************************'
print table_zero
print '********************************************'

# подготовим данные без использования NumPy

x_us = []
[x_us.append(float(i)) for i in table_zero['x']]
print x_us
print type(x_us)
print '********************************************'

y_us = []
[y_us.append(float(i)) for i in table_zero['y']]
print y_us
print type(y_us)
print '********************************************'

# подготовим данные с использованием NumPy

x_np = table_zero[['x']].values
print x_np
print type(x_np)
print x_np.shape
print '********************************************'

y_np = table_zero[['y']].values
print y_np
print type(y_np)
print y_np.shape
print '********************************************'

ದೃಶ್ಯೀಕರಣ

ಈಗ, ನಾವು ಮೊದಲು, ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಿದ ನಂತರ, ಎರಡನೆಯದಾಗಿ, ಲೋಡಿಂಗ್ನ ಸರಿಯಾದತೆಯನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಅಂತಿಮವಾಗಿ ಡೇಟಾವನ್ನು ಫಾರ್ಮಾಟ್ ಮಾಡಿದ ನಂತರ, ನಾವು ಮೊದಲ ದೃಶ್ಯೀಕರಣವನ್ನು ಕೈಗೊಳ್ಳುತ್ತೇವೆ. ಇದಕ್ಕಾಗಿ ಹೆಚ್ಚಾಗಿ ಬಳಸುವ ವಿಧಾನ ಜೋಡಿ ಕಥಾವಸ್ತು ಗ್ರಂಥಾಲಯಗಳು ಸೀಬಾರ್ನ್. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಸೀಮಿತ ಸಂಖ್ಯೆಗಳ ಕಾರಣದಿಂದಾಗಿ, ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸುವುದರಲ್ಲಿ ಯಾವುದೇ ಅರ್ಥವಿಲ್ಲ ಸೀಬಾರ್ನ್. ನಾವು ಸಾಮಾನ್ಯ ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸುತ್ತೇವೆ ಮ್ಯಾಟ್ಪ್ಲೋಟ್ಲಿಬ್ ಮತ್ತು ಕೇವಲ ಸ್ಕ್ಯಾಟರ್ಪ್ಲೋಟ್ ಅನ್ನು ನೋಡಿ.

ಸ್ಕ್ಯಾಟರ್‌ಪ್ಲಾಟ್ ಕೋಡ್

print 'График №1 "Зависимость выручки от месяца года"'

plt.plot(x_us,y_us,'o',color='green',markersize=16)
plt.xlabel('$Months$', size=16)
plt.ylabel('$Sales$', size=16)
plt.show()

ಚಾರ್ಟ್ ಸಂಖ್ಯೆ 1 "ವರ್ಷದ ತಿಂಗಳ ಆದಾಯದ ಅವಲಂಬನೆ"

ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರ

ಸಾಮಾನ್ಯ ಸಾಧನಗಳನ್ನು ಬಳಸೋಣ ಪೈಥಾನ್ ಮತ್ತು ಸಮೀಕರಣಗಳ ವ್ಯವಸ್ಥೆಯನ್ನು ಪರಿಹರಿಸಿ:

ಪ್ರಾರಂಭ{ಸಮೀಕರಣ*}
ಪ್ರಾರಂಭ{ಪ್ರಕರಣಗಳು}
na + bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i = 0

sumlimits_{i=1}^nx_i(a +bsumlimits_{i=1}^nx_i — sumlimits_{i=1}^ny_i) = 0
ಅಂತ್ಯ{ಪ್ರಕರಣಗಳು}
ಅಂತ್ಯ{ಸಮೀಕರಣ*}

ಕ್ರಾಮರ್ ನಿಯಮದ ಪ್ರಕಾರ ನಾವು ಸಾಮಾನ್ಯ ನಿರ್ಧಾರಕವನ್ನು, ಹಾಗೆಯೇ ನಿರ್ಣಾಯಕಗಳನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತೇವೆ ಮತ್ತು ಮೂಲಕ , ಅದರ ನಂತರ, ನಿರ್ಣಾಯಕವನ್ನು ಭಾಗಿಸುವುದು ಸಾಮಾನ್ಯ ನಿರ್ಧಾರಕಕ್ಕೆ - ಗುಣಾಂಕವನ್ನು ಹುಡುಕಿ , ಅದೇ ರೀತಿ ನಾವು ಗುಣಾಂಕವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ .

ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರ ಕೋಡ್

# определим функцию для расчета коэффициентов a и b по правилу Крамера
def Kramer_method (x,y):
        # сумма значений (все месяца)
    sx = sum(x)
        # сумма истинных ответов (выручка за весь период)
    sy = sum(y)
        # сумма произведения значений на истинные ответы
    list_xy = []
    [list_xy.append(x[i]*y[i]) for i in range(len(x))]
    sxy = sum(list_xy)
        # сумма квадратов значений
    list_x_sq = []
    [list_x_sq.append(x[i]**2) for i in range(len(x))]
    sx_sq = sum(list_x_sq)
        # количество значений
    n = len(x)
        # общий определитель
    det = sx_sq*n - sx*sx
        # определитель по a
    det_a = sx_sq*sy - sx*sxy
        # искомый параметр a
    a = (det_a / det)
        # определитель по b
    det_b = sxy*n - sy*sx
        # искомый параметр b
    b = (det_b / det)
        # контрольные значения (прооверка)
    check1 = (n*b + a*sx - sy)
    check2 = (b*sx + a*sx_sq - sxy)
    return [round(a,4), round(b,4)]

# запустим функцию и запишем правильные ответы
ab_us = Kramer_method(x_us,y_us)
a_us = ab_us[0]
b_us = ab_us[1]
print ' 33[1m' + ' 33[4m' + "Оптимальные значения коэффициентов a и b:"  + ' 33[0m' 
print 'a =', a_us
print 'b =', b_us
print

# определим функцию для подсчета суммы квадратов ошибок
def errors_sq_Kramer_method(answers,x,y):
    list_errors_sq = []
    for i in range(len(x)):
        err = (answers[0] + answers[1]*x[i] - y[i])**2
        list_errors_sq.append(err)
    return sum(list_errors_sq)

# запустим функцию и запишем значение ошибки
error_sq = errors_sq_Kramer_method(ab_us,x_us,y_us)
print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений" + ' 33[0m'
print error_sq
print

# замерим время расчета
# print ' 33[1m' + ' 33[4m' + "Время выполнения расчета суммы квадратов отклонений:" + ' 33[0m'
# % timeit error_sq = errors_sq_Kramer_method(ab,x_us,y_us)

ನಮಗೆ ಸಿಕ್ಕಿದ್ದು ಇಲ್ಲಿದೆ:

ಆದ್ದರಿಂದ, ಗುಣಾಂಕಗಳ ಮೌಲ್ಯಗಳು ಕಂಡುಬಂದಿವೆ, ವರ್ಗ ವಿಚಲನಗಳ ಮೊತ್ತವನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ಕಂಡುಬರುವ ಗುಣಾಂಕಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಸ್ಕ್ಯಾಟರಿಂಗ್ ಹಿಸ್ಟೋಗ್ರಾಮ್ನಲ್ಲಿ ನೇರ ರೇಖೆಯನ್ನು ಸೆಳೆಯೋಣ.

ರಿಗ್ರೆಷನ್ ಲೈನ್ ಕೋಡ್

# определим функцию для формирования массива рассчетных значений выручки
def sales_count(ab,x,y):
    line_answers = []
    [line_answers.append(ab[0]+ab[1]*x[i]) for i in range(len(x))]
    return line_answers

# построим графики
print 'Грфик№2 "Правильные и расчетные ответы"'
plt.plot(x_us,y_us,'o',color='green',markersize=16, label = '$True$ $answers$')
plt.plot(x_us, sales_count(ab_us,x_us,y_us), color='red',lw=4,
         label='$Function: a + bx,$ $where$ $a='+str(round(ab_us[0],2))+',$ $b='+str(round(ab_us[1],2))+'$')
plt.xlabel('$Months$', size=16)
plt.ylabel('$Sales$', size=16)
plt.legend(loc=1, prop={'size': 16})
plt.show()

ಚಾರ್ಟ್ ಸಂಖ್ಯೆ 2 "ಸರಿಯಾದ ಮತ್ತು ಲೆಕ್ಕಾಚಾರದ ಉತ್ತರಗಳು"

ನೀವು ಪ್ರತಿ ತಿಂಗಳು ವಿಚಲನ ಗ್ರಾಫ್ ಅನ್ನು ನೋಡಬಹುದು. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಅದರಿಂದ ಯಾವುದೇ ಮಹತ್ವದ ಪ್ರಾಯೋಗಿಕ ಮೌಲ್ಯವನ್ನು ಪಡೆಯುವುದಿಲ್ಲ, ಆದರೆ ಸರಳ ರೇಖೀಯ ಹಿಂಜರಿತ ಸಮೀಕರಣವು ವರ್ಷದ ತಿಂಗಳ ಆದಾಯದ ಅವಲಂಬನೆಯನ್ನು ಎಷ್ಟು ಚೆನ್ನಾಗಿ ನಿರೂಪಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನಮ್ಮ ಕುತೂಹಲವನ್ನು ನಾವು ಪೂರೈಸುತ್ತೇವೆ.

ವಿಚಲನ ಚಾರ್ಟ್ ಕೋಡ್

# определим функцию для формирования массива отклонений в процентах
def error_per_month(ab,x,y):
    sales_c = sales_count(ab,x,y)
    errors_percent = []
    for i in range(len(x)):
        errors_percent.append(100*(sales_c[i]-y[i])/y[i])
    return errors_percent

# построим график
print 'График№3 "Отклонения по-месячно, %"'
plt.gca().bar(x_us, error_per_month(ab_us,x_us,y_us), color='brown')
plt.xlabel('Months', size=16)
plt.ylabel('Calculation error, %', size=16)
plt.show()

ಚಾರ್ಟ್ ಸಂಖ್ಯೆ. 3 "ವಿಚಲನಗಳು, %"

ಪರಿಪೂರ್ಣವಲ್ಲ, ಆದರೆ ನಾವು ನಮ್ಮ ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ್ದೇವೆ.

ಗುಣಾಂಕಗಳನ್ನು ನಿರ್ಧರಿಸಲು ಒಂದು ಕಾರ್ಯವನ್ನು ಬರೆಯೋಣ и ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸುತ್ತದೆ ನಂಬಿ, ಹೆಚ್ಚು ನಿಖರವಾಗಿ, ನಾವು ಎರಡು ಕಾರ್ಯಗಳನ್ನು ಬರೆಯುತ್ತೇವೆ: ಒಂದು ಸ್ಯೂಡೋಯಿನ್ವರ್ಸ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಬಳಸಿ (ಪ್ರಾಯೋಗಿಕವಾಗಿ ಶಿಫಾರಸು ಮಾಡಲಾಗಿಲ್ಲ, ಏಕೆಂದರೆ ಪ್ರಕ್ರಿಯೆಯು ಕಂಪ್ಯೂಟೇಶನಲ್ ಸಂಕೀರ್ಣ ಮತ್ತು ಅಸ್ಥಿರವಾಗಿದೆ), ಇನ್ನೊಂದು ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಸಮೀಕರಣವನ್ನು ಬಳಸುತ್ತದೆ.

ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರ ಕೋಡ್ (NumPy)

# для начала добавим столбец с не изменяющимся значением в 1. 
# Данный столбец нужен для того, чтобы не обрабатывать отдельно коэффицент a
vector_1 = np.ones((x_np.shape[0],1))
x_np = table_zero[['x']].values # на всякий случай приведем в первичный формат вектор x_np
x_np = np.hstack((vector_1,x_np))

# проверим то, что все сделали правильно
print vector_1[0:3]
print x_np[0:3]
print '***************************************'
print

# напишем функцию, которая определяет значения коэффициентов a и b с использованием псевдообратной матрицы
def pseudoinverse_matrix(X, y):
    # задаем явный формат матрицы признаков
    X = np.matrix(X)
    # определяем транспонированную матрицу
    XT = X.T
    # определяем квадратную матрицу
    XTX = XT*X
    # определяем псевдообратную матрицу
    inv = np.linalg.pinv(XTX)
    # задаем явный формат матрицы ответов
    y = np.matrix(y)
    # находим вектор весов
    return (inv*XT)*y

# запустим функцию
ab_np = pseudoinverse_matrix(x_np, y_np)
print ab_np
print '***************************************'
print

# напишем функцию, которая использует для решения матричное уравнение
def matrix_equation(X,y):
    a = np.dot(X.T, X)
    b = np.dot(X.T, y)
    return np.linalg.solve(a, b)

# запустим функцию
ab_np = matrix_equation(x_np,y_np)
print ab_np

ಗುಣಾಂಕಗಳನ್ನು ನಿರ್ಧರಿಸಲು ಕಳೆದ ಸಮಯವನ್ನು ಹೋಲಿಕೆ ಮಾಡೋಣ и , ಪ್ರಸ್ತುತಪಡಿಸಿದ 3 ವಿಧಾನಗಳಿಗೆ ಅನುಗುಣವಾಗಿ.

ಲೆಕ್ಕಾಚಾರದ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಕೋಡ್

print ' 33[1m' + ' 33[4m' + "Время выполнения расчета коэффициентов без использования библиотеки NumPy:" + ' 33[0m'
% timeit ab_us = Kramer_method(x_us,y_us)
print '***************************************'
print
print ' 33[1m' + ' 33[4m' + "Время выполнения расчета коэффициентов с использованием псевдообратной матрицы:" + ' 33[0m'
%timeit ab_np = pseudoinverse_matrix(x_np, y_np)
print '***************************************'
print
print ' 33[1m' + ' 33[4m' + "Время выполнения расчета коэффициентов с использованием матричного уравнения:" + ' 33[0m'
%timeit ab_np = matrix_equation(x_np, y_np)

ಸಣ್ಣ ಪ್ರಮಾಣದ ಡೇಟಾದೊಂದಿಗೆ, "ಸ್ವಯಂ-ಲಿಖಿತ" ಕಾರ್ಯವು ಮುಂದೆ ಬರುತ್ತದೆ, ಇದು ಕ್ರೇಮರ್ನ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಗುಣಾಂಕಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ.

ಈಗ ನೀವು ಗುಣಾಂಕಗಳನ್ನು ಹುಡುಕಲು ಇತರ ಮಾರ್ಗಗಳಿಗೆ ಹೋಗಬಹುದು и .

ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್

ಮೊದಲಿಗೆ, ಗ್ರೇಡಿಯಂಟ್ ಎಂದರೇನು ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸೋಣ. ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಗ್ರೇಡಿಯಂಟ್ ಒಂದು ಕಾರ್ಯದ ಗರಿಷ್ಠ ಬೆಳವಣಿಗೆಯ ದಿಕ್ಕನ್ನು ಸೂಚಿಸುವ ಒಂದು ವಿಭಾಗವಾಗಿದೆ. ಪರ್ವತವನ್ನು ಹತ್ತುವುದರೊಂದಿಗೆ ಸಾದೃಶ್ಯದ ಮೂಲಕ, ಅಲ್ಲಿ ಗ್ರೇಡಿಯಂಟ್ ಮುಖಗಳು ಪರ್ವತದ ತುದಿಗೆ ಕಡಿದಾದ ಏರಿಳಿತವಾಗಿದೆ. ಪರ್ವತದೊಂದಿಗೆ ಉದಾಹರಣೆಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ಸಾಧ್ಯವಾದಷ್ಟು ಬೇಗ ತಗ್ಗು ಪ್ರದೇಶವನ್ನು ತಲುಪಲು ನಮಗೆ ಕಡಿದಾದ ಮೂಲದ ಅಗತ್ಯವಿದೆ ಎಂದು ನಾವು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತೇವೆ, ಅಂದರೆ ಕನಿಷ್ಠ - ಕಾರ್ಯವು ಹೆಚ್ಚಾಗದ ಅಥವಾ ಕಡಿಮೆಯಾಗದ ಸ್ಥಳ. ಈ ಹಂತದಲ್ಲಿ ಉತ್ಪನ್ನವು ಶೂನ್ಯಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಮಗೆ ಗ್ರೇಡಿಯಂಟ್ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಆಂಟಿಗ್ರೇಡಿಯಂಟ್. ಆಂಟಿಗ್ರೇಡಿಯಂಟ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯಲು ನೀವು ಗ್ರೇಡಿಯಂಟ್ ಅನ್ನು ಗುಣಿಸಬೇಕಾಗಿದೆ -1 (ಮೈನಸ್ ಒಂದು).

ಒಂದು ಕಾರ್ಯವು ಹಲವಾರು ಮಿನಿಮಾಗಳನ್ನು ಹೊಂದಬಹುದು ಎಂಬ ಅಂಶಕ್ಕೆ ನಾವು ಗಮನ ಹರಿಸೋಣ ಮತ್ತು ಕೆಳಗೆ ಪ್ರಸ್ತಾಪಿಸಲಾದ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅವುಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ಇಳಿದ ನಂತರ, ನಮಗೆ ಇನ್ನೊಂದು ಕನಿಷ್ಠವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ, ಅದು ಕಂಡುಬಂದದ್ದಕ್ಕಿಂತ ಕಡಿಮೆ ಇರಬಹುದು. ನಾವು ವಿಶ್ರಾಂತಿ ಪಡೆಯೋಣ, ಇದು ನಮಗೆ ಬೆದರಿಕೆ ಅಲ್ಲ! ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಮ್ಮ ಕಾರ್ಯದಿಂದ ನಾವು ಒಂದೇ ಕನಿಷ್ಠದೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತಿದ್ದೇವೆ ಗ್ರಾಫ್‌ನಲ್ಲಿ ಸಾಮಾನ್ಯ ಪ್ಯಾರಾಬೋಲಾ ಇದೆ. ಮತ್ತು ನಮ್ಮ ಶಾಲೆಯ ಗಣಿತದ ಕೋರ್ಸ್‌ನಿಂದ ನಾವೆಲ್ಲರೂ ಚೆನ್ನಾಗಿ ತಿಳಿದಿರಬೇಕು, ಪ್ಯಾರಾಬೋಲಾವು ಕೇವಲ ಒಂದು ಕನಿಷ್ಠವನ್ನು ಹೊಂದಿದೆ.

ನಮಗೆ ಗ್ರೇಡಿಯಂಟ್ ಏಕೆ ಬೇಕು ಎಂದು ನಾವು ಕಂಡುಕೊಂಡ ನಂತರ, ಮತ್ತು ಗ್ರೇಡಿಯಂಟ್ ಒಂದು ವಿಭಾಗವಾಗಿದೆ, ಅಂದರೆ, ನಿರ್ದಿಷ್ಟ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಹೊಂದಿರುವ ವೆಕ್ಟರ್, ಅದು ನಿಖರವಾಗಿ ಅದೇ ಗುಣಾಂಕಗಳಾಗಿವೆ и ನಾವು ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.

ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ಮೂಲದ ಅಲ್ಗಾರಿದಮ್ ಬಗ್ಗೆ ಕೆಲವೇ ವಾಕ್ಯಗಳನ್ನು ಓದಲು ನಾನು ಸಲಹೆ ನೀಡುತ್ತೇನೆ:

• ಗುಣಾಂಕಗಳ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ನಾವು ಹುಸಿ-ಯಾದೃಚ್ಛಿಕ ರೀತಿಯಲ್ಲಿ ನಿರ್ಧರಿಸುತ್ತೇವೆ и . ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಶೂನ್ಯದ ಬಳಿ ಗುಣಾಂಕಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತೇವೆ. ಇದು ಸಾಮಾನ್ಯ ಅಭ್ಯಾಸವಾಗಿದೆ, ಆದರೆ ಪ್ರತಿಯೊಂದು ಪ್ರಕರಣವೂ ತನ್ನದೇ ಆದ ಅಭ್ಯಾಸವನ್ನು ಹೊಂದಿರಬಹುದು.
• ಸಮನ್ವಯದಿಂದ ಪಾಯಿಂಟ್‌ನಲ್ಲಿ 1 ನೇ ಕ್ರಮಾಂಕದ ಭಾಗಶಃ ಉತ್ಪನ್ನದ ಮೌಲ್ಯವನ್ನು ಕಳೆಯಿರಿ . ಆದ್ದರಿಂದ, ಉತ್ಪನ್ನವು ಧನಾತ್ಮಕವಾಗಿದ್ದರೆ, ನಂತರ ಕಾರ್ಯವು ಹೆಚ್ಚಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಉತ್ಪನ್ನದ ಮೌಲ್ಯವನ್ನು ಕಳೆಯುವುದರ ಮೂಲಕ, ನಾವು ಬೆಳವಣಿಗೆಯ ವಿರುದ್ಧ ದಿಕ್ಕಿನಲ್ಲಿ, ಅಂದರೆ ಮೂಲದ ದಿಕ್ಕಿನಲ್ಲಿ ಚಲಿಸುತ್ತೇವೆ. ಉತ್ಪನ್ನವು ಋಣಾತ್ಮಕವಾಗಿದ್ದರೆ, ಈ ಹಂತದಲ್ಲಿ ಕಾರ್ಯವು ಕಡಿಮೆಯಾಗುತ್ತದೆ ಮತ್ತು ಉತ್ಪನ್ನದ ಮೌಲ್ಯವನ್ನು ಕಳೆಯುವುದರ ಮೂಲಕ ನಾವು ಮೂಲದ ದಿಕ್ಕಿನಲ್ಲಿ ಚಲಿಸುತ್ತೇವೆ.
• ನಾವು ನಿರ್ದೇಶಾಂಕದೊಂದಿಗೆ ಇದೇ ರೀತಿಯ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಡೆಸುತ್ತೇವೆ : ಹಂತದಲ್ಲಿ ಆಂಶಿಕ ಉತ್ಪನ್ನದ ಮೌಲ್ಯವನ್ನು ಕಳೆಯಿರಿ .
• ಕನಿಷ್ಠ ಜಿಗಿತವನ್ನು ಮತ್ತು ಆಳವಾದ ಬಾಹ್ಯಾಕಾಶಕ್ಕೆ ಹಾರಲು ಅಲ್ಲ ಸಲುವಾಗಿ, ಮೂಲದ ದಿಕ್ಕಿನಲ್ಲಿ ಹಂತದ ಗಾತ್ರವನ್ನು ಹೊಂದಿಸಲು ಅವಶ್ಯಕ. ಸಾಮಾನ್ಯವಾಗಿ, ಲೆಕ್ಕಾಚಾರದ ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಹಂತವನ್ನು ಹೇಗೆ ಸರಿಯಾಗಿ ಹೊಂದಿಸುವುದು ಮತ್ತು ಮೂಲದ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಅದನ್ನು ಹೇಗೆ ಬದಲಾಯಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ನೀವು ಸಂಪೂರ್ಣ ಲೇಖನವನ್ನು ಬರೆಯಬಹುದು. ಆದರೆ ಈಗ ನಮ್ಮ ಮುಂದೆ ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾದ ಕಾರ್ಯವಿದೆ, ಮತ್ತು ನಾವು "ಚುಚ್ಚುವ" ವೈಜ್ಞಾನಿಕ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಹಂತದ ಗಾತ್ರವನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ ಅಥವಾ ಅವರು ಸಾಮಾನ್ಯ ಭಾಷೆಯಲ್ಲಿ ಹೇಳುವಂತೆ ಪ್ರಾಯೋಗಿಕವಾಗಿ.
• ಒಮ್ಮೆ ನಾವು ನೀಡಿದ ನಿರ್ದೇಶಾಂಕಗಳಿಂದ ಬಂದಿದ್ದೇವೆ и ಉತ್ಪನ್ನಗಳ ಮೌಲ್ಯಗಳನ್ನು ಕಳೆಯಿರಿ, ನಾವು ಹೊಸ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ и . ನಾವು ಈಗಾಗಲೇ ಲೆಕ್ಕಾಚಾರದ ನಿರ್ದೇಶಾಂಕಗಳಿಂದ ಮುಂದಿನ ಹಂತವನ್ನು (ವ್ಯವಕಲನ) ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ. ಮತ್ತು ಅಗತ್ಯವಿರುವ ಒಮ್ಮುಖವನ್ನು ಸಾಧಿಸುವವರೆಗೆ ಚಕ್ರವು ಮತ್ತೆ ಮತ್ತೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಎಲ್ಲಾ! ಈಗ ನಾವು ಮರಿಯಾನಾ ಕಂದಕದ ಆಳವಾದ ಕಮರಿಯನ್ನು ಹುಡುಕಲು ಸಿದ್ಧರಿದ್ದೇವೆ. ನಾವೀಗ ಆರಂಭಿಸೋಣ.

ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಕೋಡ್

# напишем функцию градиентного спуска без использования библиотеки NumPy. 
# Функция на вход принимает диапазоны значений x,y, длину шага (по умолчанию=0,1), допустимую погрешность(tolerance)
def gradient_descent_usual(x_us,y_us,l=0.1,tolerance=0.000000000001):
    # сумма значений (все месяца)
    sx = sum(x_us)
    # сумма истинных ответов (выручка за весь период)
    sy = sum(y_us)
    # сумма произведения значений на истинные ответы
    list_xy = []
    [list_xy.append(x_us[i]*y_us[i]) for i in range(len(x_us))]
    sxy = sum(list_xy)
    # сумма квадратов значений
    list_x_sq = []
    [list_x_sq.append(x_us[i]**2) for i in range(len(x_us))]
    sx_sq = sum(list_x_sq)
    # количество значений
    num = len(x_us)
    # начальные значения коэффициентов, определенные псевдослучайным образом
    a = float(random.uniform(-0.5, 0.5))
    b = float(random.uniform(-0.5, 0.5))
    # создаем массив с ошибками, для старта используем значения 1 и 0
    # после завершения спуска стартовые значения удалим
    errors = [1,0]
    # запускаем цикл спуска
    # цикл работает до тех пор, пока отклонение последней ошибки суммы квадратов от предыдущей, не будет меньше tolerance
    while abs(errors[-1]-errors[-2]) > tolerance:
        a_step = a - l*(num*a + b*sx - sy)/num
        b_step = b - l*(a*sx + b*sx_sq - sxy)/num
        a = a_step
        b = b_step
        ab = [a,b]
        errors.append(errors_sq_Kramer_method(ab,x_us,y_us))
    return (ab),(errors[2:])

# запишем массив значений 
list_parametres_gradient_descence = gradient_descent_usual(x_us,y_us,l=0.1,tolerance=0.000000000001)


print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_gradient_descence[0][0],3)
print 'b =', round(list_parametres_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_gradient_descence[1][-1],3)
print



print ' 33[1m' + ' 33[4m' + "Количество итераций в градиентном спуске:" + ' 33[0m'
print len(list_parametres_gradient_descence[1])
print

ನಾವು ಮರಿಯಾನಾ ಕಂದಕದ ಕೆಳಭಾಗಕ್ಕೆ ಧುಮುಕಿದ್ದೇವೆ ಮತ್ತು ಅಲ್ಲಿ ನಾವು ಒಂದೇ ರೀತಿಯ ಗುಣಾಂಕ ಮೌಲ್ಯಗಳನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ и , ಇದು ನಿಖರವಾಗಿ ನಿರೀಕ್ಷಿಸಬೇಕಾದದ್ದು.

ನಾವು ಇನ್ನೊಂದು ಡೈವ್ ತೆಗೆದುಕೊಳ್ಳೋಣ, ಈ ಸಮಯದಲ್ಲಿ ಮಾತ್ರ, ನಮ್ಮ ಆಳ ಸಮುದ್ರದ ವಾಹನವು ಇತರ ತಂತ್ರಜ್ಞಾನಗಳಿಂದ ತುಂಬಿರುತ್ತದೆ, ಅವುಗಳೆಂದರೆ ಗ್ರಂಥಾಲಯ ನಂಬಿ.

ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಕೋಡ್ (NumPy)

# перед тем определить функцию для градиентного спуска с использованием библиотеки NumPy, 
# напишем функцию определения суммы квадратов отклонений также с использованием NumPy
def error_square_numpy(ab,x_np,y_np):
    y_pred = np.dot(x_np,ab)
    error = y_pred - y_np
    return sum((error)**2)

# напишем функцию градиентного спуска с использованием библиотеки NumPy. 
# Функция на вход принимает диапазоны значений x,y, длину шага (по умолчанию=0,1), допустимую погрешность(tolerance)
def gradient_descent_numpy(x_np,y_np,l=0.1,tolerance=0.000000000001):
    # сумма значений (все месяца)
    sx = float(sum(x_np[:,1]))
    # сумма истинных ответов (выручка за весь период)
    sy = float(sum(y_np))
    # сумма произведения значений на истинные ответы
    sxy = x_np*y_np
    sxy = float(sum(sxy[:,1]))
    # сумма квадратов значений
    sx_sq = float(sum(x_np[:,1]**2))
    # количество значений
    num = float(x_np.shape[0])
    # начальные значения коэффициентов, определенные псевдослучайным образом
    a = float(random.uniform(-0.5, 0.5))
    b = float(random.uniform(-0.5, 0.5))
    # создаем массив с ошибками, для старта используем значения 1 и 0
    # после завершения спуска стартовые значения удалим
    errors = [1,0]
    # запускаем цикл спуска
    # цикл работает до тех пор, пока отклонение последней ошибки суммы квадратов от предыдущей, не будет меньше tolerance
    while abs(errors[-1]-errors[-2]) > tolerance:
        a_step = a - l*(num*a + b*sx - sy)/num
        b_step = b - l*(a*sx + b*sx_sq - sxy)/num
        a = a_step
        b = b_step
        ab = np.array([[a],[b]])
        errors.append(error_square_numpy(ab,x_np,y_np))
    return (ab),(errors[2:])

# запишем массив значений 
list_parametres_gradient_descence = gradient_descent_numpy(x_np,y_np,l=0.1,tolerance=0.000000000001)

print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_gradient_descence[0][0],3)
print 'b =', round(list_parametres_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_gradient_descence[1][-1],3)
print

print ' 33[1m' + ' 33[4m' + "Количество итераций в градиентном спуске:" + ' 33[0m'
print len(list_parametres_gradient_descence[1])
print

ಗುಣಾಂಕ ಮೌಲ್ಯಗಳು и ಬದಲಾಯಿಸಲಾಗದ.

ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಸಮಯದಲ್ಲಿ ದೋಷವು ಹೇಗೆ ಬದಲಾಯಿತು ಎಂಬುದನ್ನು ನೋಡೋಣ, ಅಂದರೆ, ಪ್ರತಿ ಹಂತದಲ್ಲೂ ವರ್ಗ ವಿಚಲನಗಳ ಮೊತ್ತವು ಹೇಗೆ ಬದಲಾಗಿದೆ.

ವರ್ಗ ವಿಚಲನಗಳ ಮೊತ್ತವನ್ನು ಯೋಜಿಸಲು ಕೋಡ್

print 'График№4 "Сумма квадратов отклонений по-шагово"'
plt.plot(range(len(list_parametres_gradient_descence[1])), list_parametres_gradient_descence[1], color='red', lw=3)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

ಗ್ರಾಫ್ ಸಂಖ್ಯೆ 4 "ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಸಮಯದಲ್ಲಿ ವರ್ಗದ ವಿಚಲನಗಳ ಮೊತ್ತ"

ಗ್ರಾಫ್‌ನಲ್ಲಿ ಪ್ರತಿ ಹಂತದಲ್ಲೂ ದೋಷವು ಕಡಿಮೆಯಾಗುತ್ತದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಪುನರಾವರ್ತನೆಗಳ ನಂತರ ನಾವು ಬಹುತೇಕ ಸಮತಲವಾಗಿರುವ ರೇಖೆಯನ್ನು ಗಮನಿಸುತ್ತೇವೆ.

ಅಂತಿಮವಾಗಿ, ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯದ ವ್ಯತ್ಯಾಸವನ್ನು ಅಂದಾಜು ಮಾಡೋಣ:

ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಲೆಕ್ಕಾಚಾರದ ಸಮಯವನ್ನು ನಿರ್ಧರಿಸಲು ಕೋಡ್

print ' 33[1m' + ' 33[4m' + "Время выполнения градиентного спуска без использования библиотеки NumPy:" + ' 33[0m'
%timeit list_parametres_gradient_descence = gradient_descent_usual(x_us,y_us,l=0.1,tolerance=0.000000000001)
print '***************************************'
print

print ' 33[1m' + ' 33[4m' + "Время выполнения градиентного спуска с использованием библиотеки NumPy:" + ' 33[0m'
%timeit list_parametres_gradient_descence = gradient_descent_numpy(x_np,y_np,l=0.1,tolerance=0.000000000001)

ಬಹುಶಃ ನಾವು ಏನಾದರೂ ತಪ್ಪು ಮಾಡುತ್ತಿದ್ದೇವೆ, ಆದರೆ ಮತ್ತೆ ಇದು ಲೈಬ್ರರಿಯನ್ನು ಬಳಸದ ಸರಳವಾದ "ಹೋಮ್ ಲಿಖಿತ" ಕಾರ್ಯವಾಗಿದೆ ನಂಬಿ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯದ ಲೆಕ್ಕಾಚಾರದ ಸಮಯವನ್ನು ಮೀರಿಸುತ್ತದೆ ನಂಬಿ.

ಆದರೆ ನಾವು ಇನ್ನೂ ನಿಂತಿಲ್ಲ, ಆದರೆ ಸರಳ ರೇಖೀಯ ಹಿಂಜರಿತ ಸಮೀಕರಣವನ್ನು ಪರಿಹರಿಸಲು ಮತ್ತೊಂದು ರೋಮಾಂಚಕಾರಿ ಮಾರ್ಗವನ್ನು ಅಧ್ಯಯನ ಮಾಡುವತ್ತ ಸಾಗುತ್ತಿದ್ದೇವೆ. ನಮ್ಮನ್ನು ಭೇಟಿಯಾಗಿ!

ಸ್ಟೊಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣ

ಸ್ಟೊಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಕಾರ್ಯಾಚರಣೆಯ ತತ್ವವನ್ನು ತ್ವರಿತವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಸಾಮಾನ್ಯ ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಅದರ ವ್ಯತ್ಯಾಸಗಳನ್ನು ನಿರ್ಧರಿಸುವುದು ಉತ್ತಮ. ನಾವು, ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಸಂದರ್ಭದಲ್ಲಿ, ಉತ್ಪನ್ನಗಳ ಸಮೀಕರಣಗಳಲ್ಲಿ и ಮಾದರಿಯಲ್ಲಿ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ವೈಶಿಷ್ಟ್ಯಗಳ ಮೌಲ್ಯಗಳು ಮತ್ತು ನಿಜವಾದ ಉತ್ತರಗಳನ್ನು ಬಳಸಲಾಗಿದೆ (ಅಂದರೆ, ಎಲ್ಲಾ ಮೊತ್ತಗಳು и ) ಸ್ಟೊಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್‌ನಲ್ಲಿ, ನಾವು ಮಾದರಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಬದಲಿಗೆ, ಹುಸಿ-ಯಾದೃಚ್ಛಿಕವಾಗಿ ಮಾದರಿ ಸೂಚ್ಯಂಕ ಎಂದು ಕರೆಯಲ್ಪಡುವದನ್ನು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ಅದರ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸಿ.

ಉದಾಹರಣೆಗೆ, ಸೂಚ್ಯಂಕವು ಸಂಖ್ಯೆ 3 (ಮೂರು) ಎಂದು ನಿರ್ಧರಿಸಿದರೆ, ನಾವು ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ и , ನಂತರ ನಾವು ಮೌಲ್ಯಗಳನ್ನು ವ್ಯುತ್ಪನ್ನ ಸಮೀಕರಣಗಳಾಗಿ ಬದಲಿಸುತ್ತೇವೆ ಮತ್ತು ಹೊಸ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತೇವೆ. ನಂತರ, ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ನಿರ್ಧರಿಸಿದ ನಂತರ, ನಾವು ಮತ್ತೊಮ್ಮೆ ಮಾದರಿ ಸೂಚ್ಯಂಕವನ್ನು ಹುಸಿ-ಯಾದೃಚ್ಛಿಕವಾಗಿ ನಿರ್ಧರಿಸುತ್ತೇವೆ, ಸೂಚ್ಯಂಕಕ್ಕೆ ಅನುಗುಣವಾದ ಮೌಲ್ಯಗಳನ್ನು ಭಾಗಶಃ ಭೇದಾತ್ಮಕ ಸಮೀಕರಣಗಳಾಗಿ ಬದಲಿಸುತ್ತೇವೆ ಮತ್ತು ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಹೊಸ ರೀತಿಯಲ್ಲಿ ನಿರ್ಧರಿಸುತ್ತೇವೆ и ಇತ್ಯಾದಿ ಒಮ್ಮುಖವು ಹಸಿರು ಬಣ್ಣಕ್ಕೆ ತಿರುಗುವವರೆಗೆ. ಮೊದಲ ನೋಟದಲ್ಲಿ, ಇದು ಕೆಲಸ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ತೋರುತ್ತದೆ, ಆದರೆ ಅದು ಮಾಡುತ್ತದೆ. ಪ್ರತಿ ಹಂತದಲ್ಲೂ ದೋಷ ಕಡಿಮೆಯಾಗುವುದಿಲ್ಲ ಎಂದು ಗಮನಿಸಬೇಕಾದ ಸಂಗತಿ ನಿಜ, ಆದರೆ ಖಂಡಿತವಾಗಿಯೂ ಪ್ರವೃತ್ತಿ ಇದೆ.

ಸಾಂಪ್ರದಾಯಿಕಕ್ಕಿಂತ ಸ್ಟೋಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಅನುಕೂಲಗಳು ಯಾವುವು? ನಮ್ಮ ಮಾದರಿಯ ಗಾತ್ರವು ತುಂಬಾ ದೊಡ್ಡದಾಗಿದ್ದರೆ ಮತ್ತು ಹತ್ತಾರು ಸಾವಿರ ಮೌಲ್ಯಗಳಲ್ಲಿ ಅಳೆಯಲಾಗುತ್ತದೆ, ನಂತರ ಸಂಪೂರ್ಣ ಮಾದರಿಯ ಬದಲಿಗೆ ಅವುಗಳಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಸಾವಿರವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ತುಂಬಾ ಸುಲಭ. ಇಲ್ಲಿ ಸ್ಟೋಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್ ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಸಹಜವಾಗಿ, ನಾವು ಹೆಚ್ಚಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಗಮನಿಸುವುದಿಲ್ಲ.

ಕೋಡ್ ಅನ್ನು ನೋಡೋಣ.

ಸ್ಟೊಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಕೋಡ್

# определим функцию стох.град.шага
def stoch_grad_step_usual(vector_init, x_us, ind, y_us, l):
#     выбираем значение икс, которое соответствует случайному значению параметра ind 
# (см.ф-цию stoch_grad_descent_usual)
    x = x_us[ind]
#     рассчитывыаем значение y (выручку), которая соответствует выбранному значению x
    y_pred = vector_init[0] + vector_init[1]*x_us[ind]
#     вычисляем ошибку расчетной выручки относительно представленной в выборке
    error = y_pred - y_us[ind]
#     определяем первую координату градиента ab
    grad_a = error
#     определяем вторую координату ab
    grad_b = x_us[ind]*error
#     вычисляем новый вектор коэффициентов
    vector_new = [vector_init[0]-l*grad_a, vector_init[1]-l*grad_b]
    return vector_new


# определим функцию стох.град.спуска
def stoch_grad_descent_usual(x_us, y_us, l=0.1, steps = 800):
#     для самого начала работы функции зададим начальные значения коэффициентов
    vector_init = [float(random.uniform(-0.5, 0.5)), float(random.uniform(-0.5, 0.5))]
    errors = []
#     запустим цикл спуска
# цикл расчитан на определенное количество шагов (steps)
    for i in range(steps):
        ind = random.choice(range(len(x_us)))
        new_vector = stoch_grad_step_usual(vector_init, x_us, ind, y_us, l)
        vector_init = new_vector
        errors.append(errors_sq_Kramer_method(vector_init,x_us,y_us))
    return (vector_init),(errors)


# запишем массив значений 
list_parametres_stoch_gradient_descence = stoch_grad_descent_usual(x_us, y_us, l=0.1, steps = 800)

print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_stoch_gradient_descence[0][0],3)
print 'b =', round(list_parametres_stoch_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_stoch_gradient_descence[1][-1],3)
print

print ' 33[1m' + ' 33[4m' + "Количество итераций в стохастическом градиентном спуске:" + ' 33[0m'
print len(list_parametres_stoch_gradient_descence[1])

ನಾವು ಗುಣಾಂಕಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ನೋಡುತ್ತೇವೆ ಮತ್ತು "ಇದು ಹೇಗೆ ಸಾಧ್ಯ?" ಎಂಬ ಪ್ರಶ್ನೆಯನ್ನು ಕೇಳಿಕೊಳ್ಳುತ್ತೇವೆ. ನಾವು ಇತರ ಗುಣಾಂಕ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇವೆ и . ಬಹುಶಃ ಸ್ಟೋಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣವು ಸಮೀಕರಣಕ್ಕೆ ಹೆಚ್ಚು ಸೂಕ್ತವಾದ ನಿಯತಾಂಕಗಳನ್ನು ಕಂಡುಕೊಂಡಿದೆಯೇ? ದುರದೃಷ್ಟವಶಾತ್ ಇಲ್ಲ. ಸ್ಕ್ವೇರ್ಡ್ ವಿಚಲನಗಳ ಮೊತ್ತವನ್ನು ನೋಡಲು ಮತ್ತು ಗುಣಾಂಕಗಳ ಹೊಸ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ದೋಷವು ಹೆಚ್ಚಿರುವುದನ್ನು ನೋಡಲು ಸಾಕು. ನಾವು ಹತಾಶೆಗೆ ಆತುರವಿಲ್ಲ. ದೋಷ ಬದಲಾವಣೆಯ ಗ್ರಾಫ್ ಅನ್ನು ನಿರ್ಮಿಸೋಣ.

ಸ್ಟೋಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್‌ನಲ್ಲಿ ವರ್ಗದ ವಿಚಲನಗಳ ಮೊತ್ತವನ್ನು ಯೋಜಿಸಲು ಕೋಡ್

print 'График №5 "Сумма квадратов отклонений по-шагово"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1])), list_parametres_stoch_gradient_descence[1], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

ಗ್ರಾಫ್ ಸಂಖ್ಯೆ 5 "ಸ್ಟೊಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಸಮಯದಲ್ಲಿ ವರ್ಗದ ವಿಚಲನಗಳ ಮೊತ್ತ"

ವೇಳಾಪಟ್ಟಿಯನ್ನು ನೋಡುವಾಗ, ಎಲ್ಲವೂ ಸ್ಥಳಕ್ಕೆ ಬರುತ್ತವೆ ಮತ್ತು ಈಗ ನಾವು ಎಲ್ಲವನ್ನೂ ಸರಿಪಡಿಸುತ್ತೇವೆ.

ಹಾಗಾದರೆ ಏನಾಯಿತು? ಕೆಳಗಿನವು ಸಂಭವಿಸಿದವು. ನಾವು ಯಾದೃಚ್ಛಿಕವಾಗಿ ತಿಂಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಿದಾಗ, ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ಆದಾಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವಲ್ಲಿ ದೋಷವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಬಯಸುತ್ತದೆ. ನಂತರ ನಾವು ಇನ್ನೊಂದು ತಿಂಗಳು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ಲೆಕ್ಕಾಚಾರವನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತೇವೆ, ಆದರೆ ಎರಡನೇ ಆಯ್ಕೆಮಾಡಿದ ತಿಂಗಳಿಗೆ ನಾವು ದೋಷವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತೇವೆ. ಮೊದಲ ಎರಡು ತಿಂಗಳುಗಳು ಸರಳ ರೇಖಾತ್ಮಕ ಹಿಂಜರಿತ ಸಮೀಕರಣದ ರೇಖೆಯಿಂದ ಗಮನಾರ್ಹವಾಗಿ ವಿಚಲನಗೊಳ್ಳುತ್ತವೆ ಎಂಬುದನ್ನು ಈಗ ನೆನಪಿಡಿ. ಇದರರ್ಥ ಈ ಎರಡು ತಿಂಗಳುಗಳಲ್ಲಿ ಯಾವುದನ್ನಾದರೂ ಆಯ್ಕೆಮಾಡಿದಾಗ, ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದರ ದೋಷವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ, ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ಸಂಪೂರ್ಣ ಮಾದರಿಯ ದೋಷವನ್ನು ಗಂಭೀರವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತದೆ. ಹಾಗಾದರೆ ಏನು ಮಾಡಬೇಕು? ಉತ್ತರ ಸರಳವಾಗಿದೆ: ನೀವು ಮೂಲದ ಹಂತವನ್ನು ಕಡಿಮೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಎಲ್ಲಾ ನಂತರ, ಮೂಲದ ಹಂತವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ, ದೋಷವು "ಜಂಪಿಂಗ್" ಅನ್ನು ಮೇಲಕ್ಕೆ ಮತ್ತು ಕೆಳಕ್ಕೆ ನಿಲ್ಲಿಸುತ್ತದೆ. ಅಥವಾ ಬದಲಿಗೆ, "ಜಂಪಿಂಗ್" ದೋಷವು ನಿಲ್ಲುವುದಿಲ್ಲ, ಆದರೆ ಅದು ಬೇಗನೆ ಮಾಡುವುದಿಲ್ಲ :) ಪರಿಶೀಲಿಸೋಣ.

ಸಣ್ಣ ಏರಿಕೆಗಳೊಂದಿಗೆ SGD ರನ್ ಮಾಡಲು ಕೋಡ್

# запустим функцию, уменьшив шаг в 100 раз и увеличив количество шагов соответсвующе 
list_parametres_stoch_gradient_descence = stoch_grad_descent_usual(x_us, y_us, l=0.001, steps = 80000)

print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_stoch_gradient_descence[0][0],3)
print 'b =', round(list_parametres_stoch_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_stoch_gradient_descence[1][-1],3)
print



print ' 33[1m' + ' 33[4m' + "Количество итераций в стохастическом градиентном спуске:" + ' 33[0m'
print len(list_parametres_stoch_gradient_descence[1])

print 'График №6 "Сумма квадратов отклонений по-шагово"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1])), list_parametres_stoch_gradient_descence[1], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

ಗ್ರಾಫ್ ಸಂಖ್ಯೆ. 6 "ಸ್ಟೊಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣ (80 ಸಾವಿರ ಹಂತಗಳು) ಸಮಯದಲ್ಲಿ ವರ್ಗ ವಿಚಲನಗಳ ಮೊತ್ತ"

ಗುಣಾಂಕಗಳು ಸುಧಾರಿಸಿವೆ, ಆದರೆ ಇನ್ನೂ ಸೂಕ್ತವಲ್ಲ. ಕಾಲ್ಪನಿಕವಾಗಿ, ಇದನ್ನು ಈ ರೀತಿ ಸರಿಪಡಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಕೊನೆಯ 1000 ಪುನರಾವರ್ತನೆಗಳಲ್ಲಿ ಕನಿಷ್ಠ ದೋಷವನ್ನು ಹೊಂದಿರುವ ಗುಣಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು ನಾವು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ. ನಿಜ, ಇದಕ್ಕಾಗಿ ನಾವು ಗುಣಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು ಸಹ ಬರೆಯಬೇಕಾಗುತ್ತದೆ. ನಾವು ಇದನ್ನು ಮಾಡುವುದಿಲ್ಲ, ಆದರೆ ವೇಳಾಪಟ್ಟಿಗೆ ಗಮನ ಕೊಡಿ. ಇದು ಸುಗಮವಾಗಿ ಕಾಣುತ್ತದೆ ಮತ್ತು ದೋಷವು ಸಮವಾಗಿ ಕಡಿಮೆಯಾಗುತ್ತದೆ ಎಂದು ತೋರುತ್ತದೆ. ವಾಸ್ತವವಾಗಿ ಇದು ನಿಜವಲ್ಲ. ಮೊದಲ 1000 ಪುನರಾವರ್ತನೆಗಳನ್ನು ನೋಡೋಣ ಮತ್ತು ಅವುಗಳನ್ನು ಕೊನೆಯದರೊಂದಿಗೆ ಹೋಲಿಸಿ.

SGD ಚಾರ್ಟ್‌ಗಾಗಿ ಕೋಡ್ (ಮೊದಲ 1000 ಹಂತಗಳು)

print 'График №7 "Сумма квадратов отклонений по-шагово. Первые 1000 итераций"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1][:1000])), 
         list_parametres_stoch_gradient_descence[1][:1000], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

print 'График №7 "Сумма квадратов отклонений по-шагово. Последние 1000 итераций"'
plt.plot(range(len(list_parametres_stoch_gradient_descence[1][-1000:])), 
         list_parametres_stoch_gradient_descence[1][-1000:], color='red', lw=2)
plt.xlabel('Steps (Iteration)', size=16)
plt.ylabel('Sum of squared deviations', size=16)
plt.show()

ಗ್ರಾಫ್ ಸಂಖ್ಯೆ 7 "ವರ್ಗದ ವಿಚಲನಗಳ ಮೊತ್ತ SGD (ಮೊದಲ 1000 ಹಂತಗಳು)"

ಗ್ರಾಫ್ ಸಂಖ್ಯೆ 8 "ವರ್ಗದ ವಿಚಲನಗಳ ಮೊತ್ತ SGD (ಕೊನೆಯ 1000 ಹಂತಗಳು)"

ಮೂಲದ ಅತ್ಯಂತ ಆರಂಭದಲ್ಲಿ, ದೋಷದಲ್ಲಿ ಸಾಕಷ್ಟು ಏಕರೂಪದ ಮತ್ತು ಕಡಿದಾದ ಇಳಿಕೆಯನ್ನು ನಾವು ಗಮನಿಸುತ್ತೇವೆ. ಕೊನೆಯ ಪುನರಾವರ್ತನೆಗಳಲ್ಲಿ, ದೋಷವು 1,475 ರ ಮೌಲ್ಯದ ಸುತ್ತಲೂ ಮತ್ತು ಕೆಲವು ಕ್ಷಣಗಳಲ್ಲಿ ಈ ಅತ್ಯುತ್ತಮ ಮೌಲ್ಯಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ, ಆದರೆ ಅದು ಇನ್ನೂ ಹೆಚ್ಚಾಗುತ್ತದೆ ... ನಾನು ಪುನರಾವರ್ತಿಸುತ್ತೇನೆ, ನೀವು ಮೌಲ್ಯಗಳನ್ನು ಬರೆಯಬಹುದು ಗುಣಾಂಕಗಳು и , ತದನಂತರ ದೋಷವು ಕಡಿಮೆ ಇರುವಂತಹವುಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿ. ಆದಾಗ್ಯೂ, ನಾವು ಹೆಚ್ಚು ಗಂಭೀರವಾದ ಸಮಸ್ಯೆಯನ್ನು ಹೊಂದಿದ್ದೇವೆ: ನಾವು 80 ಸಾವಿರ ಹಂತಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಕಾಗಿತ್ತು (ಕೋಡ್ ನೋಡಿ) ಮೌಲ್ಯಗಳನ್ನು ಆಪ್ಟಿಮಲ್ ಹತ್ತಿರ ಪಡೆಯಲು. ಮತ್ತು ಇದು ಈಗಾಗಲೇ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಸ್ಟೋಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣದೊಂದಿಗೆ ಕಂಪ್ಯೂಟೇಶನ್ ಸಮಯವನ್ನು ಉಳಿಸುವ ಕಲ್ಪನೆಯನ್ನು ವಿರೋಧಿಸುತ್ತದೆ. ಏನು ಸರಿಪಡಿಸಬಹುದು ಮತ್ತು ಸುಧಾರಿಸಬಹುದು? ಮೊದಲ ಪುನರಾವರ್ತನೆಗಳಲ್ಲಿ ನಾವು ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ಕೆಳಗಿಳಿಯುತ್ತೇವೆ ಮತ್ತು ಆದ್ದರಿಂದ, ನಾವು ಮೊದಲ ಪುನರಾವರ್ತನೆಗಳಲ್ಲಿ ದೊಡ್ಡ ಹೆಜ್ಜೆಯನ್ನು ಬಿಡಬೇಕು ಮತ್ತು ನಾವು ಮುಂದೆ ಸಾಗುವಾಗ ಹಂತವನ್ನು ಕಡಿಮೆಗೊಳಿಸಬೇಕು ಎಂದು ಗಮನಿಸುವುದು ಕಷ್ಟವೇನಲ್ಲ. ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಇದನ್ನು ಮಾಡುವುದಿಲ್ಲ - ಇದು ಈಗಾಗಲೇ ತುಂಬಾ ಉದ್ದವಾಗಿದೆ. ಬಯಸುವವರು ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ಸ್ವತಃ ಯೋಚಿಸಬಹುದು, ಇದು ಕಷ್ಟವೇನಲ್ಲ :)

ಈಗ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟೋಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣವನ್ನು ಮಾಡೋಣ ನಂಬಿ (ಮತ್ತು ನಾವು ಮೊದಲೇ ಗುರುತಿಸಿದ ಕಲ್ಲುಗಳ ಮೇಲೆ ಮುಗ್ಗರಿಸಬಾರದು)

ಸ್ಟೊಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್‌ಗಾಗಿ ಕೋಡ್ (NumPy)

# для начала напишем функцию градиентного шага
def stoch_grad_step_numpy(vector_init, X, ind, y, l):
    x = X[ind]
    y_pred = np.dot(x,vector_init)
    err = y_pred - y[ind]
    grad_a = err
    grad_b = x[1]*err
    return vector_init - l*np.array([grad_a, grad_b])

# определим функцию стохастического градиентного спуска
def stoch_grad_descent_numpy(X, y, l=0.1, steps = 800):
    vector_init = np.array([[np.random.randint(X.shape[0])], [np.random.randint(X.shape[0])]])
    errors = []
    for i in range(steps):
        ind = np.random.randint(X.shape[0])
        new_vector = stoch_grad_step_numpy(vector_init, X, ind, y, l)
        vector_init = new_vector
        errors.append(error_square_numpy(vector_init,X,y))
    return (vector_init), (errors)

# запишем массив значений 
list_parametres_stoch_gradient_descence = stoch_grad_descent_numpy(x_np, y_np, l=0.001, steps = 80000)

print ' 33[1m' + ' 33[4m' + "Значения коэффициентов a и b:" + ' 33[0m'
print 'a =', round(list_parametres_stoch_gradient_descence[0][0],3)
print 'b =', round(list_parametres_stoch_gradient_descence[0][1],3)
print


print ' 33[1m' + ' 33[4m' + "Сумма квадратов отклонений:" + ' 33[0m'
print round(list_parametres_stoch_gradient_descence[1][-1],3)
print



print ' 33[1m' + ' 33[4m' + "Количество итераций в стохастическом градиентном спуске:" + ' 33[0m'
print len(list_parametres_stoch_gradient_descence[1])
print

ಬಳಸದೆಯೇ ಅವರೋಹಣ ಮಾಡುವಾಗ ಮೌಲ್ಯಗಳು ಬಹುತೇಕ ಒಂದೇ ಆಗಿವೆ ನಂಬಿ. ಆದಾಗ್ಯೂ, ಇದು ತಾರ್ಕಿಕವಾಗಿದೆ.

ಸ್ಟೋಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣಗಳು ನಮ್ಮನ್ನು ಎಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಂಡವು ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯೋಣ.

SGD ಲೆಕ್ಕಾಚಾರದ ಸಮಯವನ್ನು ನಿರ್ಧರಿಸುವ ಕೋಡ್ (80 ಸಾವಿರ ಹಂತಗಳು)

print ' 33[1m' + ' 33[4m' +
"Время выполнения стохастического градиентного спуска без использования библиотеки NumPy:"
+ ' 33[0m'
%timeit list_parametres_stoch_gradient_descence = stoch_grad_descent_usual(x_us, y_us, l=0.001, steps = 80000)
print '***************************************'
print

print ' 33[1m' + ' 33[4m' +
"Время выполнения стохастического градиентного спуска с использованием библиотеки NumPy:"
+ ' 33[0m'
%timeit list_parametres_stoch_gradient_descence = stoch_grad_descent_numpy(x_np, y_np, l=0.001, steps = 80000)

ಕಾಡಿನೊಳಗೆ ಮತ್ತಷ್ಟು, ಮೋಡಗಳು ಗಾಢವಾಗುತ್ತವೆ: ಮತ್ತೊಮ್ಮೆ, "ಸ್ವಯಂ-ಲಿಖಿತ" ಸೂತ್ರವು ಉತ್ತಮ ಫಲಿತಾಂಶವನ್ನು ತೋರಿಸುತ್ತದೆ. ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸಲು ಇನ್ನೂ ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮವಾದ ಮಾರ್ಗಗಳು ಇರಬೇಕೆಂದು ಇದೆಲ್ಲವೂ ಸೂಚಿಸುತ್ತದೆ ನಂಬಿ, ಇದು ನಿಜವಾಗಿಯೂ ಕಂಪ್ಯೂಟೇಶನ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ. ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಅವರ ಬಗ್ಗೆ ಕಲಿಯುವುದಿಲ್ಲ. ನಿಮ್ಮ ಬಿಡುವಿನ ವೇಳೆಯಲ್ಲಿ ಯೋಚಿಸಲು ಏನಾದರೂ ಇರುತ್ತದೆ :)

ಸಾರಾಂಶ

ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸುವ ಮೊದಲು, ನಮ್ಮ ಪ್ರಿಯ ಓದುಗರಿಂದ ಹೆಚ್ಚಾಗಿ ಉದ್ಭವಿಸಿದ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು ನಾನು ಬಯಸುತ್ತೇನೆ. ಏಕೆ, ವಾಸ್ತವವಾಗಿ, ಅವರೋಹಣದೊಂದಿಗೆ ಅಂತಹ "ಚಿತ್ರಹಿಂಸೆ", ಅಮೂಲ್ಯವಾದ ತಗ್ಗು ಪ್ರದೇಶವನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಾವು ಪರ್ವತದ ಮೇಲೆ ಮತ್ತು ಕೆಳಗೆ (ಹೆಚ್ಚಾಗಿ ಕೆಳಗೆ) ಏಕೆ ನಡೆಯಬೇಕು, ನಮ್ಮ ಕೈಯಲ್ಲಿ ಅಂತಹ ಶಕ್ತಿಯುತ ಮತ್ತು ಸರಳವಾದ ಸಾಧನವಿದ್ದರೆ, ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರದ ರೂಪ, ಇದು ತಕ್ಷಣವೇ ನಮ್ಮನ್ನು ಸರಿಯಾದ ಸ್ಥಳಕ್ಕೆ ಟೆಲಿಪೋರ್ಟ್ ಮಾಡುತ್ತದೆ?

ಈ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರವು ಮೇಲ್ಮೈಯಲ್ಲಿದೆ. ಈಗ ನಾವು ಸರಳವಾದ ಉದಾಹರಣೆಯನ್ನು ನೋಡಿದ್ದೇವೆ, ಅದರಲ್ಲಿ ನಿಜವಾದ ಉತ್ತರವಿದೆ ಒಂದು ಚಿಹ್ನೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ . ಜೀವನದಲ್ಲಿ ನೀವು ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ನೋಡುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು 2, 30, 50 ಅಥವಾ ಹೆಚ್ಚಿನ ಚಿಹ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಊಹಿಸೋಣ. ಪ್ರತಿ ಗುಣಲಕ್ಷಣಕ್ಕೆ ಸಾವಿರಾರು ಅಥವಾ ಹತ್ತಾರು ಸಾವಿರ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸೋಣ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಿಶ್ಲೇಷಣಾತ್ಮಕ ಪರಿಹಾರವು ಪರೀಕ್ಷೆಯನ್ನು ತಡೆದುಕೊಳ್ಳುವುದಿಲ್ಲ ಮತ್ತು ವಿಫಲವಾಗಬಹುದು. ಪ್ರತಿಯಾಗಿ, ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣ ಮತ್ತು ಅದರ ವ್ಯತ್ಯಾಸಗಳು ನಿಧಾನವಾಗಿ ಆದರೆ ಖಚಿತವಾಗಿ ನಮ್ಮನ್ನು ಗುರಿಯ ಹತ್ತಿರಕ್ಕೆ ತರುತ್ತವೆ - ಕಾರ್ಯದ ಕನಿಷ್ಠ. ಮತ್ತು ವೇಗದ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಡಿ - ಹಂತದ ಉದ್ದವನ್ನು (ಅಂದರೆ ವೇಗ) ಹೊಂದಿಸಲು ಮತ್ತು ನಿಯಂತ್ರಿಸಲು ನಮಗೆ ಅನುಮತಿಸುವ ಮಾರ್ಗಗಳನ್ನು ನಾವು ಬಹುಶಃ ನೋಡುತ್ತೇವೆ.

ಮತ್ತು ಈಗ ನಿಜವಾದ ಸಂಕ್ಷಿಪ್ತ ಸಾರಾಂಶ.

ಮೊದಲನೆಯದಾಗಿ, ಸರಳವಾದ (ಮತ್ತು ಮಾತ್ರವಲ್ಲ) ರೇಖೀಯ ಹಿಂಜರಿತ ಸಮೀಕರಣಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಲೇಖನದಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾದ ವಸ್ತುವು "ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳನ್ನು" ಪ್ರಾರಂಭಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

ಎರಡನೆಯದಾಗಿ, ಸಮೀಕರಣವನ್ನು ಪರಿಹರಿಸಲು ನಾವು ಹಲವಾರು ಮಾರ್ಗಗಳನ್ನು ನೋಡಿದ್ದೇವೆ. ಈಗ, ಪರಿಸ್ಥಿತಿಯನ್ನು ಅವಲಂಬಿಸಿ, ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಸೂಕ್ತವಾದದನ್ನು ನಾವು ಆಯ್ಕೆ ಮಾಡಬಹುದು.

ಮೂರನೆಯದಾಗಿ, ನಾವು ಹೆಚ್ಚುವರಿ ಸೆಟ್ಟಿಂಗ್‌ಗಳ ಶಕ್ತಿಯನ್ನು ನೋಡಿದ್ದೇವೆ, ಅವುಗಳೆಂದರೆ ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಹಂತದ ಉದ್ದ. ಈ ನಿಯತಾಂಕವನ್ನು ನಿರ್ಲಕ್ಷಿಸಲಾಗುವುದಿಲ್ಲ. ಮೇಲೆ ಗಮನಿಸಿದಂತೆ, ಲೆಕ್ಕಾಚಾರಗಳ ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ಇಳಿಯುವಿಕೆಯ ಸಮಯದಲ್ಲಿ ಹಂತದ ಉದ್ದವನ್ನು ಬದಲಾಯಿಸಬೇಕು.

ನಾಲ್ಕನೆಯದಾಗಿ, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, "ಹೋಮ್-ಲಿಖಿತ" ಕಾರ್ಯಗಳು ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಉತ್ತಮ ಸಮಯ ಫಲಿತಾಂಶಗಳನ್ನು ತೋರಿಸಿದೆ. ಇದು ಬಹುಶಃ ಗ್ರಂಥಾಲಯದ ಸಾಮರ್ಥ್ಯಗಳ ವೃತ್ತಿಪರ ಬಳಕೆಯಲ್ಲದ ಕಾರಣ ನಂಬಿ. ಆದರೆ ಅದು ಇರಲಿ, ಈ ಕೆಳಗಿನ ತೀರ್ಮಾನವು ಸ್ವತಃ ಸೂಚಿಸುತ್ತದೆ. ಒಂದೆಡೆ, ಕೆಲವೊಮ್ಮೆ ಸ್ಥಾಪಿತ ಅಭಿಪ್ರಾಯಗಳನ್ನು ಪ್ರಶ್ನಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ, ಮತ್ತು ಮತ್ತೊಂದೆಡೆ, ಎಲ್ಲವನ್ನೂ ಸಂಕೀರ್ಣಗೊಳಿಸುವುದು ಯಾವಾಗಲೂ ಯೋಗ್ಯವಾಗಿಲ್ಲ - ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಕೆಲವೊಮ್ಮೆ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಸರಳವಾದ ಮಾರ್ಗವು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ. ಮತ್ತು ಸರಳವಾದ ರೇಖಾತ್ಮಕ ಹಿಂಜರಿತ ಸಮೀಕರಣವನ್ನು ಪರಿಹರಿಸಲು ಮೂರು ವಿಧಾನಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು ನಮ್ಮ ಗುರಿಯಾಗಿರುವುದರಿಂದ, "ಸ್ವಯಂ-ಲಿಖಿತ" ಕಾರ್ಯಗಳ ಬಳಕೆ ನಮಗೆ ಸಾಕಷ್ಟು ಸಾಕಾಗಿತ್ತು.

ಸಾಹಿತ್ಯ (ಅಥವಾ ಹಾಗೆ)

1. ಲೀನಿಯರ್ ರಿಗ್ರೆಷನ್

http://statistica.ru/theory/osnovy-lineynoy-regressii/

2. ಕಡಿಮೆ ಚೌಕಗಳ ವಿಧಾನ

mathprofi.ru/metod_naimenshih_kvadratov.html

3. ಉತ್ಪನ್ನ

www.mathprofi.ru/chastnye_proizvodnye_primery.html

4. ಗ್ರೇಡಿಯಂಟ್

mathprofi.ru/proizvodnaja_po_napravleniju_i_gradient.html

5. ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣ

habr.com/en/post/471458

habr.com/en/post/307312

artemarakcheev.com//2017-12-31/linear_regression

6. NumPy ಲೈಬ್ರರಿ

docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.linalg.solve.html

docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.linalg.pinv.html

pythonworld.ru/numpy/2.html

ಮೂಲ: www.habr.com