NumPy એ Python પ્રોગ્રામિંગની દુનિયામાં એક શક્તિશાળી અને વ્યાપકપણે ઉપયોગમાં લેવાતી લાઇબ્રેરી છે. તે ઉચ્ચ-પ્રદર્શન બહુપરિમાણીય એરે ઑબ્જેક્ટ અને આ એરે સાથે કામ કરવા માટેના સાધનો પૂરા પાડે છે. આવી જ એક વિશેષતા છે પ્રદર્શન કરવાની ક્ષમતા રોલિંગ વિન્ડો ગણતરીઓ નમ્પી લાઇબ્રેરીનો ઉપયોગ કરીને. આ લેખમાં, અમે નમ્પી લાઇબ્રેરીનો ઉપયોગ કરીને રોલિંગ વિન્ડો ગણતરીઓ પર ધ્યાન આપીશું અને આ તકનીકનો ઉપયોગ કરીને ઉકેલી શકાય તેવી સમસ્યાનો ઉકેલ રજૂ કરીશું. અમે કોડનું પગલું-દર-પગલાં સમજૂતી પણ પ્રદાન કરીશું અને આ પ્રક્રિયામાં સામેલ સંબંધિત લાઇબ્રેરીઓ અને કાર્યોની ચર્ચા કરીશું.
રોલિંગ વિન્ડોની ગણતરીઓને સમજવી
રોલિંગ વિન્ડો ગણતરીઓ જેવા ક્ષેત્રોમાં ડેટાનું વિશ્લેષણ કરવાની સામાન્ય પદ્ધતિ છે ફાઇનાન્સ, સિગ્નલ પ્રોસેસિંગ અને હવામાનશાસ્ત્ર. આ ટેકનિક પાછળનો મુખ્ય વિચાર ડેટાને નિશ્ચિત-કદની ઓવરલેપિંગ વિન્ડોમાં વિભાજીત કરવાનો છે, જેનું અનુક્રમે વિશ્લેષણ કરવામાં આવે છે. આ પેટર્ન, વલણો અને વિસંગતતાઓને શોધવા માટે પરવાનગી આપે છે જે સમગ્ર ડેટાસેટને ધ્યાનમાં લેતી વખતે દૃશ્યમાન ન હોઈ શકે.
રોલિંગ વિન્ડોની ગણતરીમાં મુખ્ય ખ્યાલ એ વિન્ડોનું કદ છે. વિન્ડો સાઈઝ નક્કી કરે છે કે એક ગણતરીમાં કેટલા ડેટા પોઈન્ટ ગણવામાં આવે છે. વિન્ડોનું નાનું કદ વધુ સંવેદનશીલ પૃથ્થકરણમાં પરિણમશે, જે ડેટામાં સ્થાનિક ફેરફારોને ઝડપથી પસંદ કરશે. બીજી તરફ, વિન્ડોનું મોટું કદ વિવિધતાઓને સરળ બનાવશે, જે ડેટાનું વધુ સામાન્યકૃત દૃશ્ય પ્રદાન કરશે.
ઉકેલ: નમ્પીનો ઉપયોગ કરીને રોલિંગ વિન્ડો ગણતરી
ચાલો એક સમસ્યાને ધ્યાનમાં લઈએ જ્યાં અમારી પાસે ડેટાની એક-પરિમાણીય નમ્પી એરે છે અને અમે આપેલ વિન્ડો કદ સાથે રોલિંગ સરેરાશની ગણતરી કરવા માંગીએ છીએ. આ સમસ્યાને ઉકેલવા માટે, અમે એક ફંક્શન અમલમાં મુકીશું જે ઇનપુટ ડેટા અને વિન્ડો સાઈઝને દલીલો તરીકે લે છે અને numpy નો ઉપયોગ કરીને રોલિંગ સરેરાશ પરત કરે છે. અહીં ઉકેલ માટે કોડ છે:
એનપી તરીકે નમ્પી આયાત કરો
def rolling_mean(ડેટા, વિન્ડો_સાઇઝ):
જો window_size <= 0: raise ValueError("વિંડોનું કદ 0 કરતા વધારે હોવું જોઈએ") cumsum = np.cumsum(data) cumsum[window_size:] = cumsum[:-window_size] + data[window_size-1:] - data[ :-window_size] કમસમ પરત કરો[window_size - 1:] / window_size [/code]
કોડનું પગલું દ્વારા પગલું સમજૂતી
1. પ્રથમ, અમે np તરીકે numpy લાઇબ્રેરી આયાત કરીએ છીએ, જે Python સમુદાયમાં પ્રમાણભૂત સંમેલન છે.
2. પછી અમે rolling_mean ફંક્શનને વ્યાખ્યાયિત કરીએ છીએ, જે બે દલીલો લે છે: ઇનપુટ ડેટા અને વિન્ડોનું કદ. ઇનપુટ ડેટા એક-પરિમાણીય નમ્પી એરે હોવાની અપેક્ષા છે, અને વિન્ડોનું કદ 0 કરતા વધારે પૂર્ણાંક છે.
3. આગળ, અમે તપાસીએ છીએ કે વિન્ડોનું કદ 0 કરતા વધારે છે કે કેમ. જો તે નથી, તો અમે યોગ્ય સંદેશ સાથે ValueError વધારીએ છીએ.
4. અમે નમ્પી કમસમ ફંક્શનનો ઉપયોગ કરીને ઇનપુટ ડેટાના સંચિત સરવાળાની ગણતરી કરીએ છીએ, જે આપેલ અક્ષ સાથે તત્વોના સંચિત સરવાળાની ગણતરી કરે છે.
5. મુખ્ય ગણતરી નીચેની લીટીમાં થાય છે, જ્યાં આપણે વિન્ડો માપને અનુરૂપ યોગ્ય તત્વો બાદબાકી અને ઉમેરીને સંચિત સરવાળા એરેને અપડેટ કરીએ છીએ. આ લૂપ્સ અથવા સૂચિની સમજણના ઉપયોગની તુલનામાં વધુ કાર્યક્ષમ અભિગમ છે કારણ કે નમ્પી ઑપરેશન્સ વેક્ટરાઇઝ્ડ અને પ્રભાવ માટે ઑપ્ટિમાઇઝ કરવામાં આવે છે.
6. છેલ્લે, અમે 'વિન્ડો_સાઇઝ – 1' ઇન્ડેક્સથી શરૂ કરીને, વિન્ડો સાઇઝ દ્વારા અપડેટ કરેલ સંચિત સરવાળા એરેને વિભાજિત કરીને રોલિંગ સરેરાશ પરત કરીએ છીએ.
rolling_mean ફંક્શનનો ઉપયોગ હવે કોઈપણ એક-પરિમાણીય નમ્પી એરે પર રોલિંગ વિન્ડોની ગણતરીઓ કરવા માટે થઈ શકે છે.
સમાન પુસ્તકાલયો અને કાર્યો
- પાંડા: પાયથોનમાં ડેટા મેનીપ્યુલેશન અને એનાલિસિસ માટેની આ લોકપ્રિય લાઇબ્રેરી બિલ્ટ-ઇન રોલિંગ પદ્ધતિ પ્રદાન કરે છે જે પાંડા ડેટાફ્રેમ અને સિરીઝ ઑબ્જેક્ટ્સ પર રોલિંગ વિન્ડોની ગણતરીની પ્રક્રિયાને સરળ બનાવે છે.
- SciPy: SciPy લાઇબ્રેરી, જે numpy પર બને છે, સિગ્નલ પ્રોસેસિંગ માટે વધારાના કાર્યો આપે છે, જેમ કે આપેલ વિન્ડો માપ સાથે મૂવિંગ એવરેજ કરવા માટે uniform_filter ફંક્શન.
નિષ્કર્ષમાં, નમ્પી રોલિંગ વિન્ડોની ગણતરીઓના કાર્યક્ષમ અને બહુમુખી અમલીકરણ માટે પરવાનગી આપે છે. મુખ્ય ખ્યાલો અને તકનીકોને સમજીને, વ્યક્તિ તેમના ડેટાનું વધુ સારી રીતે વિશ્લેષણ કરી શકે છે અને છુપાયેલા દાખલાઓ અને વલણોને ઉજાગર કરી શકે છે. વધુમાં, પાંડા અને SciPy માંથી સમાન લાઇબ્રેરીઓ અને કાર્યોનો લાભ લેવાથી પાયથોનમાં રોલિંગ વિન્ડો વિશ્લેષણની ક્ષમતાઓને વધુ વધારી શકાય છે.
