પાયથોન સાથે ઓટોમોટિવ ડેટા વિશ્લેષણ: એન્ડ-ટુ-એન્ડ

નફો:

• પુનરાવર્તિત વિશ્લેષણ વર્કફ્લો સ્થાપિત કરવાની ક્ષમતા જે પાંડા સાથે ટેલિમેટ્રી, પરીક્ષણ અને ઉત્પાદન ડેટાને લોડ કરે છે અને સાફ કરે છે
• આર્ટિફિશિયલ ઇન્ટેલિજન્સમાંથી કોડ, એટ્રિબ્યુટ્સ અને વિઝ્યુલાઇઝેશન સહાયતા પ્રાપ્ત કરતી વખતે આઉટપુટ લાઇનને સમજવા અને ચકાસવાની ક્ષમતા
• એકમ સુસંગતતા, ડેટા લીકેજ અને પુનઃઉત્પાદનક્ષમતા માટે વિશ્લેષણ પરિણામોનું ઓડિટ કરવાની ક્ષમતા

અગાઉના એકમોમાં, અમે "સલાહકાર"ની જેમ કૃત્રિમ બુદ્ધિનો ઉપયોગ કર્યો હતો. આ એકમમાં, અમે એક ડગલું આગળ વધીએ છીએ અને એક વર્કફ્લો સ્થાપિત કરીએ છીએ જે પાયથોનનો ઉપયોગ કરીને આપણા પોતાના હાથથી ઓટોમોટિવ ડેટાનું વિશ્લેષણ કરે છે. ધ્યેય તમને સોફ્ટવેર ડેવલપર બનાવવાનો નથી; તે એક એન્જિનિયર બનાવવાનું છે જે AI તરફથી કોડ સહાયતા મેળવતી વખતે તે કોડ લાઇનને લાઇન દ્વારા સમજી અને ચકાસી શકે. કારણ કે AI દ્વારા ઉત્પાદિત કોડ ખામીયુક્ત હોઈ શકે છે, જેમ કે AI દ્વારા ઉત્પાદિત ટેક્સ્ટ; વોલ્યુમ, લીક ડેટા, કેન્દ્રમાં ખોટી કૉલમ ગૂંચવી શકે છે. કોડને સમજ્યા વિના ચલાવવું એ સહી વિનાનો અહેવાલ પ્રકાશિત કરવા જેવું છે.

અજગર શા માટે? કારણ કે તે ડેટા વિશ્લેષણમાં વાસ્તવિક ધોરણ છે: તમે ટેલિમેટ્રી, ટેસ્ટ અને ઉત્પાદન ડેટાને પાંડા (ટેબ્યુલર ડેટા), નમ્પી (સંખ્યાત્મક પ્રક્રિયા), મેટપ્લોટલિબ (પ્લોટ) અને સ્કિકિટ-લર્ન (મશીન લર્નિંગ) લાઇબ્રેરીઓ સાથે સરળતાથી પ્રક્રિયા કરી શકો છો.

પ્રજનનક્ષમ વિશ્લેષણ માટે છ પગલાં

નક્કર વિશ્લેષણ હંમેશા સમાન માળખાને અનુસરે છે:

1. લોડ કરો: ફાઇલમાંથી ડેટા વાંચો.
2. તપાસો: પરિમાણ, કૉલમ, ડેટા પ્રકારો, ખૂટતા મૂલ્યો.
3. સ્વચ્છ: ખૂટે છે/આઉટલીયર, એકમ, ટાઇમસ્ટેમ્પ કરેક્શન.
4. અર્ક લક્ષણ: અર્થપૂર્ણ ચલો મેળવો.
5. વિશ્લેષણ/મોડલ: આંકડા, વિઝ્યુલાઇઝેશન અથવા મોડેલ.
6. ચકાસો અને જાણ કરો: પરિણામની જોગવાઈ, વોલ્યુમ/લીક તપાસ, રેકોર્ડિંગ.

ટીપ: AI ને કોડ માટે પૂછતી વખતે, "તમે દરેક પગલા પર શું કરી રહ્યા છો તેની ટિપ્પણી કરો અને તમારી ધારણાઓ લખો" કહો. તેથી તમે કોડ વાંચતા જ તેને ચકાસી શકો છો.

પગલું દ્વારા પગલું ઉદાહરણ: ટેલિમેટ્રી વિશ્લેષણ

નીચેનો કોડ CAN/ટેલિમેટ્રી રેકોર્ડ લોડ કરે છે અને મૂળભૂત તપાસ કરે છે. (નોંધ: કોડ ચલાવતા પહેલા ખાતરી કરો કે તમે તેને સમજો છો; કૉલમના નામ તમારા ડેટાના આધારે બદલાય છે.)

pd# 1 તરીકે પંડા આયાત કરો ટેક્સ્ટ)પ્રિન્ટ(df.isna().સમ()) # કૉલમપ્રિન્ટ દીઠ ખૂટતા મૂલ્યોની સંખ્યા(df.describe()) # સારાંશ આંકડા: ન્યૂનતમ, મહત્તમ, સરેરાશ

describe() આઉટપુટ એ ચકાસવાની તમારી પ્રથમ તક છે: જો એન્જિનની ઝડપ મહત્તમ મૂલ્ય 45,000 rpm (સામાન્ય પેસેન્જર એન્જિન ~7,000 rpm) હોય, તો એકમ અથવા સેન્સરમાં ખામી છે.

ઓડિટીંગ પગલામાં સૌથી વધુ ઉપયોગમાં લેવાતા પાંડા આદેશો અને તેઓ શું કરે છે:

આદેશ

શું કરે છે

તે શું પુષ્ટિ કરે છે?

df.shape

પંક્તિઓ/સ્તંભોની સંખ્યા

શું તે અપેક્ષિત કદ છે?

df.dtypes

કૉલમ પ્રકારો

શું નંબર કોલમ ટેક્સ્ટ બની ગઈ છે?

df.isna().સમ()

મૂલ્યની ગણતરી ખૂટે છે

કેટલી જગ્યા છે?

df.describe()

ન્યૂનતમ/મહત્તમ/સરેરાશ

શું તે શારીરિક રીતે વાજબી છે?

df.ડુપ્લિકેટ().સમ()

ડુપ્લિકેટ પંક્તિ

શું ત્યાં દ્વિ નોંધણી છે?

# 3) સાફ કરો: ભૌતિક રીતે અશક્ય મૂલ્યોને ચિહ્નિત કરો

સાવધાન: આઉટલીયરને તરત જ કાઢી નાખશો નહીં; પહેલા સમજો કે તે શા માટે આઉટલીયર છે. શું તે વાસ્તવિક ઘટના (અચાનક ગરમી) અથવા સેન્સરની નિષ્ફળતા છે? આંધળા રીતે કાઢી નાખવાથી વાસ્તવિક દોષ છુપાવી શકાય છે.

# 4) એક્સટ્રેક્ટ ફીચર: તાપમાનમાં વધારો દર (ડેરિવેટિવ)df = df.sort_values("time")df["sic_increase_speed"] = df["motor_sic"].diff() / df["time"].diff().dt.total_seconds()#5t.plotimilization તરીકે #5t. pltplt.plot(df["time"], df["motor_sic"])plt.xlabel("સમય"); plt.ylabel("એન્જિન તાપમાન (C)")plt.title("એન્જિન તાપમાન કોર્સ")plt.show()

પાયથોનમાં ડેટા લિકેજ અટકાવવું

આગાહી મોડેલ બનાવતી વખતે સૌથી ખતરનાક ભૂલ એ ડેટા લિકેજ છે (એકમ 5): જ્યારે મોડેલ એવી માહિતી જુએ છે જે આગાહીના સમયે જાણી શકાતી નથી. સમય શ્રેણીમાં આને ટાળવા માટેનો સુવર્ણ નિયમ: ભૂતકાળ સાથે તાલીમ, ભવિષ્ય સાથે પરીક્ષણ — કોઈ રેન્ડમ શફલિંગ નહીં.

sklearn.model_selection માંથી આયાત કરો train_test_split# FALSE: અવ્યવસ્થિત રીતે સમય શ્રેણીને વિભાજિત કરવાથી ભવિષ્ય# df[df["time"] > થ્રેશોલ્ડ] # છેલ્લું 20% ભવિષ્ય

સાવધાન: ટ્રેન_ટેસ્ટ_સ્પ્લિટ ડેટાને ડિફોલ્ટ રૂપે શફલ કરે છે (શફલ=ટ્રુ). સમય શ્રેણીમાં, આ ભવિષ્યને શિક્ષણ સાથે ગૂંચવણમાં મૂકે છે અને ખોટા ઉચ્ચ સ્કોરનું નિર્માણ કરે છે. જો AI એ બનાવેલ કોડમાં આ કર્યું હોય, તો તેને ઠીક કરવાની ખાતરી કરો.

એકમ સુસંગતતા: સાયલન્ટ કિલર

ઓટોમોટિવમાં સૌથી વધુ કપટી ભૂલો એકમ ભૂલો છે: km/h થી m/s, Nm થી lb-ft, bar to kPa, °C થી K. વિશ્લેષણમાં દરેક કૉલમનું એકમ શું છે તેનો શબ્દકોશ રાખવાથી અને રૂપાંતરણોને સ્પષ્ટપણે લખવાથી જીવન બચે છે.

# એકમોને સ્પષ્ટપણે દસ્તાવેજ કરો = {"સ્પીડ": "km/h", "motor_sic": "C", "પ્રેશર": "bar"}# જો જરૂરી હોય તો સ્પષ્ટ રૂપાંતર (km/h -> m/s)df["speed_ms"] = df["speed"] / 3.6

મિની કેસ સ્ટડીઝ

કેસ 1 - describe() સાથે ભૂલ પકડાઈ. વિશ્લેષક AI માંથી કોડ ચલાવે છે અને શ્રેણીનો અંદાજ બનાવે છે; પરિણામ અસ્પષ્ટપણે ઉચ્ચ છે. જ્યારે આપણે describe() આઉટપુટ જોઈએ છીએ, ત્યારે આપણે જોઈએ છીએ કે બેટરીની ક્ષમતા કેટલીક લાઈનોમાં Wh અને અન્યમાં kWh (1000 ગણો તફાવત) દાખલ કરવામાં આવી છે. જ્યારે એકમને સમાન પ્રકારમાં લાવવામાં આવે છે, ત્યારે પરિણામ સુધરે છે. નિષ્કર્ષ: એક સરળ સારાંશના આંકડા ખરાબ આગાહીને અટકાવે છે.

કેસ 2 - મૂંઝવણ છટકું. ઇન્ટર્નનું બ્રેક વેર મોડલ ટેસ્ટ સેટ પર 98% સચોટ હતું. જ્યારે કોડની તપાસ કરવામાં આવે છે, ત્યારે તે જોઈ શકાય છે કે train_test_split(shuffle=True) અને સમય શ્રેણી મિશ્રિત છે, જેનો અર્થ છે કે ભવિષ્યના મુદ્દાઓ તાલીમમાં લીક થાય છે. જ્યારે સમય દ્વારા વિભાજિત કરવામાં આવે છે, ત્યારે ચોકસાઈ ઘટીને 80% થઈ જાય છે, પરંતુ તે હવે વાસ્તવિક છે. નિષ્કર્ષ: માત્ર કારણ કે AI કોડ કામ કરતો હતો, તે યોગ્ય ન હતું; માનવે લીક પકડ્યું.

કેસ 3 - આઉટલીયરને સમજવું. ટકાઉપણું રેકોર્ડમાં, AI કોડ આપમેળે બાહ્ય તાણ મૂલ્યોને કાઢી નાખે છે. ઈજનેર કાઢી નાખેલ પોઈન્ટ જુએ છે; ક્રેકની શરૂઆતની આ ચોક્કસ ક્ષણો હતી જેમાં પરીક્ષણને રસ હતો. કાઢી નાખવાનું દૂર કરવામાં આવે છે અને ઉલ્લંઘનોને અલગ સમીક્ષામાં લેવામાં આવે છે. પરિણામ: "સફાઈ" હેઠળ વાસ્તવિક સંકેત કાઢી શકાય છે; દરેક પગલે પ્રશ્ન કરો.

પ્રોમ્પ્ટ નમૂનાઓ

નમૂનો 1 - વિનંતી કોડ (સમજીકરણ સાથે):

ભૂમિકા: તમે પાયથોન ડેટા વિશ્લેષક માર્ગદર્શક છો. કાર્ય: કોડ લખો કે જે ટેલિમેટ્રી CSV લોડ કરે છે અને તપાસે છે. સંદર્ભ: કૉલમ્સ: સમય, ઝડપ(km/h), engine_sic(C), ક્રાંતિ(rpm). અવરોધ: દરેક પંક્તિ પર ટિપ્પણી કરો; સમજાવો કે કયો ચેક કરવામાં આવ્યો હતો અને શા માટે; ભૌતિક રીતે અશક્ય મૂલ્ય તપાસ ઉમેરો; ચુપચાપ કંઈપણ કાઢી રહ્યું નથી. આઉટપુટ: કોમેન્ટ કરેલ કોડ + કયું આઉટપુટ મારે જોવું જોઈએ અને શા માટે.

નમૂનો 2 - લીક નિરીક્ષણ:

ભૂમિકા: તમે મશીન લર્નિંગ કોડ સમીક્ષક છો. કાર્ય: ડેટા લીક માટે નીચેની તાલીમ/ટેસ્ટ સ્પ્લિટ કોડ તપાસો. સંદર્ભ: આ એક સમય શ્રેણી છે (વાહન ટેલિમેટ્રી). અવરોધ: જો ત્યાં રેન્ડમ શફલિંગ હોય તો ચેતવણી આપો; સમય પ્રમાણે વિભાજન સૂચવો અને ન્યાયી ઠેરવો. આઉટપુટ: તારણો + સુધારેલ કોડ + સમજૂતી.

નમૂનો 3 - એકમ માન્યતા:

ભૂમિકા: તમે ડેટા ક્વોલિટી ઓડિટર છો. કાર્ય: ડેટાફ્રેમમાં એકમ અસંગતતા જોવા માટે તપાસો સૂચવો. સંદર્ભ: ક્ષમતા કેટલીક હરોળમાં kWh અને અન્યમાં Wh હોઈ શકે છે. આઉટપુટ: કોડ + શંકાસ્પદ પેટર્ન કેવી રીતે શોધવી તે તપાસો.

નમૂનો 4 - વિઝ્યુલાઇઝેશન + ટિપ્પણી:

ભૂમિકા: તમે ડેટા વિઝ્યુલાઇઝેશન નિષ્ણાત છો. કાર્ય: કોડ લખો જે એન્જિનના તાપમાનનો અભ્યાસક્રમ અને વધારાનો દર દર્શાવે છે. અવરોધ: એકમ સાથે અક્ષોને લેબલ કરો; વિસંગતતાને દૃષ્ટિની રીતે ચિહ્નિત કરો; ગ્રાફનું અર્થઘટન કરતી વખતે ચોક્કસ ખામીનો દાવો કરશો નહીં. આઉટપુટ: કોડ + ગ્રાફમાં શું જોવાનું છે.

નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ

નબળા પ્રોમ્પ્ટ:

આ ડેટા સાથે એક મોડેલ બનાવો.

કયો ટાર્ગેટ, કયો ડબ્બો, કયો વેરિફિકેશન એ સ્પષ્ટ નથી; AI સ્ક્રેમ્બલ્ડ, લીકી, યુનિટ-બ્લાઈન્ડ કોડ આઉટપુટ કરી શકે છે.

શક્તિશાળી પ્રોમ્પ્ટ:

ભૂમિકા: તમે Python ML માર્ગદર્શક છો. કાર્ય: બ્રેક પેડ પહેરવાની આગાહી કરવા માટે પ્રારંભિક વર્કફ્લો લખો અને માન્યતા ક્ષતિઓ દર્શાવો. સંદર્ભ: સમય શ્રેણી ટેલિમેટ્રી; લક્ષ્ય: બાકીની પેડની જાડાઈ. નિયંત્રણ: સમય દ્વારા વિભાજિત સમય શ્રેણી (કોઈ શફલિંગ નહીં); ડેટા લિકેજના જોખમમાં ફ્લેગ લક્ષણો; દસ્તાવેજ એકમો;દરેક પગલાનું અર્થઘટન; ફિલ્ડમાં પરિણામ બહાર આવે તે પહેલાં કયા ચેકની જરૂર છે તે લખો. આઉટપુટ: ટિપ્પણી કરેલ કોડ + ચકાસણી ચેકલિસ્ટ.

સામાન્ય ભૂલો

• કોડને સમજ્યા વગર ચલાવી રહ્યા છીએ. AI કોડ પણ ખામીયુક્ત હોઈ શકે છે; વાક્ય દ્વારા વાક્ય વાંચો.
• મિશ્રણ સમય શ્રેણી. shuffle=True ભવિષ્યને લીક કરે છે અને નકલી સ્કોર બનાવે છે.
• આંખ બંધ કરીને આઉટલીયર કાઢી નાખો. વાસ્તવિક સંકેત (ફોલ્ટ શરૂઆત) સાફ કરી શકાય છે.
• એકમનું દસ્તાવેજીકરણ નથી. km/h vs m/s, Wh vs kWh જેવી ભૂલો શાંતિથી વધે છે.
• describe()/ચેક સ્ટેપને અવગણી રહ્યા છીએ. મોટાભાગની ભૂલો પ્રથમ સારાંશના આંકડામાં દેખાય છે.

સારાંશમાં

• પાયથોન (પાંડા, નમ્પી, મેટપ્લોટલિબ, સ્કિકિટ-લર્ન) એ ઓટોમોટિવ ડેટા વિશ્લેષણનું વાસ્તવિક ધોરણ છે.
• પુનરાવર્તિત વિશ્લેષણ: લોડ કરો, નિરીક્ષણ કરો, સાફ કરો, લક્ષણ આપો, વિશ્લેષણ કરો, માન્ય કરો અને રિપોર્ટ કરો.
• કોડને સમજવું અને ચકાસવું હિતાવહ છે કે AI લાઇન બાય લાઇન બનાવે છે; માત્ર કારણ કે તે કામ કરે છે તેનો અર્થ એ નથી કે તે યોગ્ય છે.
• સમય શ્રેણીમાં ભૂતકાળ/ભવિષ્યનો ભેદ જાળવો; રેન્ડમ શફલિંગ ડેટા લીકેજ બનાવે છે.
• એકમ સુસંગતતા અને બાહ્ય અર્થઘટન શાંત પરંતુ ચકાસણીના નિર્ણાયક મુદ્દાઓ છે.

એપ્લિકેશન કાર્ય

એક નાનો ડેટા સેટ લો (વાસ્તવિક અથવા કૃત્રિમ ટેલિમેટ્રી). (1) છ-પગલાની ફ્રેમવર્કને અનુસરીને, ટેમ્પલેટ 1 સાથે લોડિંગ અને કંટ્રોલ કોડ જનરેટ કરો અને ખાતરી કરો કે તમે દરેક લાઇનને સમજો છો. (2) describe() આઉટપુટમાં ઓછામાં ઓછું એક શંકાસ્પદ મૂલ્ય શોધો અને શા માટે તપાસ કરો. (3) આગાહીના કાર્યમાં, તાલીમ/પરીક્ષણને વિભાજિત કરવાનો સમય આપો અને નમૂના 2 સાથે લીકેજનું જોખમ તપાસો. (4) તમે શબ્દકોશમાં ઉપયોગ કરો છો તે દરેક કૉલમના એકમને દસ્તાવેજ કરો.

ચેકલિસ્ટ

• [ ] મેં છ-પગલાની ફ્રેમવર્ક સાથે વિશ્લેષણ સેટ કર્યું છે.
• [ ] મેં AI લાઇન દ્વારા ઉત્પાદિત કોડ વાંચ્યો અને સમજ્યો.
• [ ] મેં describe()/audit સાથે શંકાસ્પદ મૂલ્યો જોયા.
• [ ] મેં સમયની શ્રેણીને સમય પ્રમાણે વિભાજિત કરી છે (કોઈ શફલિંગ નહીં).
• [ ] ડેટા લીક થવાનું જોખમ હોય તેવા લક્ષણોને મેં ચિહ્નિત કર્યા છે.
• [ ] મેં દરેક કૉલમના એકમનું દસ્તાવેજીકરણ કર્યું અને રૂપાંતરણો સ્પષ્ટપણે લખ્યા.