ਪਾਈਥਨ ਦੇ ਨਾਲ ਆਟੋਮੋਟਿਵ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ: ਅੰਤ ਤੋਂ ਅੰਤ

ਲਾਭ:

• ਇੱਕ ਦੁਹਰਾਉਣ ਯੋਗ ਵਿਸ਼ਲੇਸ਼ਣ ਵਰਕਫਲੋ ਸਥਾਪਤ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਜੋ ਪਾਂਡਾ ਦੇ ਨਾਲ ਟੈਲੀਮੈਟਰੀ, ਟੈਸਟ ਅਤੇ ਉਤਪਾਦਨ ਡੇਟਾ ਨੂੰ ਲੋਡ ਅਤੇ ਸਾਫ਼ ਕਰਦਾ ਹੈ
• ਨਕਲੀ ਬੁੱਧੀ ਤੋਂ ਕੋਡ, ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਸਹਾਇਤਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਸਮੇਂ ਆਉਟਪੁੱਟ ਲਾਈਨ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਸਮਝਣ ਅਤੇ ਤਸਦੀਕ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
• ਯੂਨਿਟ ਦੀ ਇਕਸਾਰਤਾ, ਡੇਟਾ ਲੀਕੇਜ ਅਤੇ ਪ੍ਰਜਨਨਯੋਗਤਾ ਲਈ ਆਡਿਟ ਵਿਸ਼ਲੇਸ਼ਣ ਨਤੀਜਿਆਂ ਦੀ ਯੋਗਤਾ

ਪਿਛਲੀਆਂ ਇਕਾਈਆਂ ਵਿੱਚ, ਅਸੀਂ "ਸਲਾਹਕਾਰ" ਵਾਂਗ ਨਕਲੀ ਬੁੱਧੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਸੀ। ਇਸ ਯੂਨਿਟ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਕਦਮ ਹੋਰ ਅੱਗੇ ਜਾਂਦੇ ਹਾਂ ਅਤੇ ਇੱਕ ਵਰਕਫਲੋ ਸਥਾਪਤ ਕਰਦੇ ਹਾਂ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਸਾਡੇ ਆਪਣੇ ਹੱਥਾਂ ਨਾਲ ਆਟੋਮੋਟਿਵ ਡੇਟਾ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ। ਟੀਚਾ ਤੁਹਾਨੂੰ ਇੱਕ ਸਾਫਟਵੇਅਰ ਡਿਵੈਲਪਰ ਬਣਾਉਣਾ ਨਹੀਂ ਹੈ; ਇਹ ਇੱਕ ਇੰਜਨੀਅਰ ਬਣਾਉਣਾ ਹੈ ਜੋ ਏਆਈ ਤੋਂ ਕੋਡ ਸਹਾਇਤਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋਏ ਉਸ ਕੋਡ ਲਾਈਨ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਸਮਝ ਅਤੇ ਤਸਦੀਕ ਕਰ ਸਕਦਾ ਹੈ। ਕਿਉਂਕਿ AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਕੋਡ ਨੁਕਸਦਾਰ ਹੋ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ AI ਦੁਆਰਾ ਤਿਆਰ ਟੈਕਸਟ; ਵਾਲੀਅਮ ਨੂੰ ਉਲਝਾ ਸਕਦਾ ਹੈ, ਡੇਟਾ ਲੀਕ ਕਰ ਸਕਦਾ ਹੈ, ਗਲਤ ਕਾਲਮ ਨੂੰ ਕੇਂਦਰ ਵਿੱਚ ਰੱਖ ਸਕਦਾ ਹੈ। ਕੋਡ ਨੂੰ ਸਮਝੇ ਬਿਨਾਂ ਇਸ ਨੂੰ ਚਲਾਉਣਾ ਇੱਕ ਹਸਤਾਖਰਿਤ ਰਿਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਦੇ ਬਰਾਬਰ ਹੈ।

ਪਾਈਥਨ ਕਿਉਂ? ਕਿਉਂਕਿ ਇਹ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਅਸਲ ਮਿਆਰ ਹੈ: ਤੁਸੀਂ ਪਾਂਡਾ (ਟੇਬਿਊਲਰ ਡੇਟਾ), ਨੰਪੀ (ਸੰਖਿਆਤਮਕ ਪ੍ਰੋਸੈਸਿੰਗ), ਮੈਟਪਲੋਟਲਿਬ (ਪਲਾਟ) ਅਤੇ ਸਕਿਟ-ਲਰਨ (ਮਸ਼ੀਨ ਲਰਨਿੰਗ) ਲਾਇਬ੍ਰੇਰੀਆਂ ਨਾਲ ਟੈਲੀਮੈਟਰੀ, ਟੈਸਟ ਅਤੇ ਉਤਪਾਦਨ ਡੇਟਾ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਪ੍ਰੋਸੈਸ ਕਰ ਸਕਦੇ ਹੋ।

ਪ੍ਰਜਨਨਯੋਗ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਛੇ ਕਦਮ

ਇੱਕ ਠੋਸ ਵਿਸ਼ਲੇਸ਼ਣ ਹਮੇਸ਼ਾ ਉਸੇ ਫਰੇਮਵਰਕ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ:

1. ਲੋਡ ਕਰੋ: ਫਾਈਲ ਤੋਂ ਡੇਟਾ ਪੜ੍ਹੋ।
2. ਨਿਰੀਖਣ ਕਰੋ: ਮਾਪ, ਕਾਲਮ, ਡਾਟਾ ਕਿਸਮ, ਗੁੰਮ ਮੁੱਲ।
3. ਸਾਫ਼: ਗੁੰਮ/ਆਊਟਲੀਅਰ, ਯੂਨਿਟ, ਟਾਈਮਸਟੈਂਪ ਸੁਧਾਰ।
4. ਐਕਸਟਰੈਕਟ ਵਿਸ਼ੇਸ਼ਤਾ: ਅਰਥਪੂਰਨ ਵੇਰੀਏਬਲ ਪ੍ਰਾਪਤ ਕਰੋ।
5. ਵਿਸ਼ਲੇਸ਼ਣ/ਮਾਡਲ: ਅੰਕੜੇ, ਦ੍ਰਿਸ਼ਟੀਕੋਣ, ਜਾਂ ਮਾਡਲ।
6. ਪੁਸ਼ਟੀ ਕਰੋ ਅਤੇ ਰਿਪੋਰਟ ਕਰੋ: ਨਤੀਜਾ ਪ੍ਰਬੰਧ, ਵਾਲੀਅਮ/ਲੀਕ ਜਾਂਚ, ਰਿਕਾਰਡਿੰਗ।

ਸੁਝਾਅ: ਜਦੋਂ ਏਆਈ ਨੂੰ ਕੋਡ ਲਈ ਪੁੱਛੋ, ਤਾਂ ਕਹੋ ਕਿ "ਹਰ ਪੜਾਅ 'ਤੇ ਤੁਸੀਂ ਕੀ ਕਰ ਰਹੇ ਹੋ, ਟਿੱਪਣੀ ਕਰੋ ਅਤੇ ਆਪਣੀਆਂ ਧਾਰਨਾਵਾਂ ਲਿਖੋ।" ਇਸ ਲਈ ਤੁਸੀਂ ਕੋਡ ਦੀ ਪੁਸ਼ਟੀ ਕਰ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਤੁਸੀਂ ਇਸਨੂੰ ਪੜ੍ਹਦੇ ਹੋ।

ਕਦਮ-ਦਰ-ਕਦਮ ਉਦਾਹਰਨ: ਟੈਲੀਮੈਟਰੀ ਵਿਸ਼ਲੇਸ਼ਣ

ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਇੱਕ CAN/ਟੈਲੀਮੈਟਰੀ ਰਿਕਾਰਡ ਲੋਡ ਕਰਦਾ ਹੈ ਅਤੇ ਬੁਨਿਆਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। (ਨੋਟ: ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਕੋਡਾਂ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਉਹਨਾਂ ਨੂੰ ਸਮਝਦੇ ਹੋ; ਕਾਲਮ ਦੇ ਨਾਮ ਤੁਹਾਡੇ ਡੇਟਾ ਦੇ ਅਧਾਰ 'ਤੇ ਵੱਖ-ਵੱਖ ਹੁੰਦੇ ਹਨ।)

ਪਾਂਡਾ ਨੂੰ pd# ਦੇ ਤੌਰ 'ਤੇ ਆਯਾਤ ਕਰੋ 1) ਲੋਡ ਕਰੋ: ਅਰਧ-ਬਿੰਦੀ ਵਾਲੀ CSV, ਪਹਿਲਾ ਕਾਲਮ timestampdf = pd.read_csv("telemetry.csv", parse_dates=["time"])# 2) ਚੈਕਪ੍ਰਿੰਟ(df.shape) # ਕਿੰਨੀਆਂ ਕਤਾਰਾਂ, ਕਿੰਨੇ ਕਾਲਮਪ੍ਰਿੰਟ (df.shape) # ਹਰ ਇੱਕ ਕੋਮ ਦੀ ਕਿਸਮ (df.nty) ਟੈਕਸਟ)ਪ੍ਰਿੰਟ(df.isna().sum()) # ਪ੍ਰਤੀ ਕਾਲਮਪ੍ਰਿੰਟ ਗੁੰਮ ਮੁੱਲਾਂ ਦੀ ਸੰਖਿਆ(df.describe()) # ਸੰਖੇਪ ਅੰਕੜੇ: ਘੱਟੋ-ਘੱਟ, ਅਧਿਕਤਮ, ਔਸਤ

describe() ਆਉਟਪੁੱਟ ਤਸਦੀਕ ਕਰਨ ਦਾ ਤੁਹਾਡਾ ਪਹਿਲਾ ਮੌਕਾ ਹੈ: ਜੇਕਰ ਇੰਜਣ ਦੀ ਗਤੀ ਅਧਿਕਤਮ ਮੁੱਲ 45,000 rpm (ਆਮ ਯਾਤਰੀ ਇੰਜਣ ~7,000 rpm) ਹੈ, ਤਾਂ ਇੱਕ ਯੂਨਿਟ ਜਾਂ ਸੈਂਸਰ ਨੁਕਸ ਹੈ।

ਆਡਿਟਿੰਗ ਪੜਾਅ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੇ ਜਾਂਦੇ ਪਾਂਡਾ ਕਮਾਂਡਾਂ ਅਤੇ ਉਹ ਕੀ ਕਰਦੇ ਹਨ:

ਹੁਕਮ

ਕੀ ਕਰਦਾ ਹੈ

ਇਹ ਕੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ?

df.shape

ਕਤਾਰਾਂ/ਕਾਲਮਾਂ ਦੀ ਸੰਖਿਆ

ਕੀ ਇਹ ਅਨੁਮਾਨਤ ਆਕਾਰ ਹੈ?

df.dtypes

ਕਾਲਮ ਦੀਆਂ ਕਿਸਮਾਂ

ਕੀ ਨੰਬਰ ਕਾਲਮ ਟੈਕਸਟ ਬਣ ਗਿਆ ਹੈ?

df.isna().sum()

ਗੁੰਮ ਮੁੱਲ ਗਿਣਤੀ

ਕਿੰਨੀ ਥਾਂ ਹੈ?

df.describe()

ਨਿਊਨਤਮ/ਅਧਿਕਤਮ/ਔਸਤ

ਕੀ ਇਹ ਸਰੀਰਕ ਤੌਰ 'ਤੇ ਵਾਜਬ ਹੈ?

df.duplicated().sum()

ਡੁਪਲੀਕੇਟ ਕਤਾਰ

ਕੀ ਇੱਥੇ ਦੋਹਰੀ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਹੈ?

# 3) ਸਾਫ਼: ਸਰੀਰਕ ਤੌਰ 'ਤੇ ਅਸੰਭਵ ਮੁੱਲਾਂ ਨੂੰ ਚਿੰਨ੍ਹਿਤ ਕਰੋ

ਸਾਵਧਾਨ: ਆਊਟਲਾਇਰ ਨੂੰ ਤੁਰੰਤ ਨਾ ਮਿਟਾਓ; ਪਹਿਲਾਂ ਸਮਝੋ ਕਿ ਇਹ ਆਊਟਲਾਇਰ ਕਿਉਂ ਹੈ। ਕੀ ਇਹ ਇੱਕ ਅਸਲੀ ਘਟਨਾ (ਅਚਾਨਕ ਹੀਟਿੰਗ) ਜਾਂ ਸੈਂਸਰ ਦੀ ਅਸਫਲਤਾ ਹੈ? ਅੰਨ੍ਹੇਵਾਹ ਮਿਟਾਉਣ ਨਾਲ ਅਸਲ ਨੁਕਸ ਛੁਪ ਸਕਦਾ ਹੈ।

# 4) ਐਕਸਟਰੈਕਟ ਵਿਸ਼ੇਸ਼ਤਾ: ਤਾਪਮਾਨ ਵਾਧੇ ਦੀ ਦਰ (ਡੈਰੀਵੇਟਿਵ)df = df.sort_values("time")df["sic_increase_speed"] = df["motor_sic"].diff() / df["time"].diff().dt.total_seconds()# 5t. pyt ploimization ਦੇ ਤੌਰ 'ਤੇ ਸਿਮਟਲ ਪੋਰਟ. pltplt.plot(df["time"], df["motor_sic"])plt.xlabel("ਸਮਾਂ"); plt.ylabel("ਇੰਜਣ ਤਾਪਮਾਨ (C)")plt.title("ਇੰਜਣ ਤਾਪਮਾਨ ਕੋਰਸ")plt.show()

ਪਾਈਥਨ ਵਿੱਚ ਡਾਟਾ ਲੀਕ ਹੋਣ ਨੂੰ ਰੋਕਣਾ

ਇੱਕ ਪੂਰਵ-ਅਨੁਮਾਨ ਮਾਡਲ ਬਣਾਉਣ ਵੇਲੇ ਸਭ ਤੋਂ ਖ਼ਤਰਨਾਕ ਗਲਤੀ ਹੈ ਡੇਟਾ ਲੀਕੇਜ (ਯੂਨਿਟ 5): ਜਦੋਂ ਮਾਡਲ ਅਜਿਹੀ ਜਾਣਕਾਰੀ ਵੇਖਦਾ ਹੈ ਜੋ ਭਵਿੱਖਬਾਣੀ ਦੇ ਸਮੇਂ ਨਹੀਂ ਜਾਣੀ ਜਾ ਸਕਦੀ ਹੈ। ਸਮੇਂ ਦੀ ਲੜੀ ਵਿੱਚ ਇਸ ਤੋਂ ਬਚਣ ਲਈ ਸੁਨਹਿਰੀ ਨਿਯਮ: ਅਤੀਤ ਦੇ ਨਾਲ ਟ੍ਰੇਨ ਕਰੋ, ਭਵਿੱਖ ਦੇ ਨਾਲ ਟੈਸਟ ਕਰੋ - ਕੋਈ ਬੇਤਰਤੀਬ ਸ਼ਫਲਿੰਗ ਨਹੀਂ।

sklearn.model_selection import train_test_split# FALSE: ਬੇਤਰਤੀਬੇ ਸਮੇਂ ਦੀ ਲੜੀ ਨੂੰ ਵੰਡਣ ਨਾਲ ਭਵਿੱਖ# df[df["time"] > ਥ੍ਰੈਸ਼ਹੋਲਡ] # ਆਖਰੀ 20% ਭਵਿੱਖ ਲੀਕ ਹੋ ਜਾਂਦਾ ਹੈ

ਸਾਵਧਾਨ: train_test_split ਮੂਲ ਰੂਪ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸ਼ਫਲ ਕਰਦਾ ਹੈ (ਸ਼ਫਲ=ਸੱਚਾ)। ਸਮਾਂ ਲੜੀ ਵਿੱਚ, ਇਹ ਸਿੱਖਿਆ ਦੇ ਨਾਲ ਭਵਿੱਖ ਨੂੰ ਉਲਝਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਗਲਤ ਉੱਚ ਸਕੋਰ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਜੇਕਰ AI ਨੇ ਇਹ ਆਪਣੇ ਦੁਆਰਾ ਬਣਾਏ ਕੋਡ ਵਿੱਚ ਕੀਤਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਠੀਕ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ।

ਯੂਨਿਟ ਇਕਸਾਰਤਾ: ਚੁੱਪ ਕਾਤਲ

ਆਟੋਮੋਟਿਵ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਧੋਖੇਬਾਜ਼ ਗਲਤੀਆਂ ਯੂਨਿਟ ਦੀਆਂ ਗਲਤੀਆਂ ਹਨ: km/h ਤੋਂ m/s, Nm ਤੋਂ lb-ft, ਬਾਰ ਤੋਂ kPa, °C ਤੋਂ K। ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਹਰੇਕ ਕਾਲਮ ਦੀ ਇਕਾਈ ਕੀ ਹੈ ਇਸ ਦਾ ਸ਼ਬਦਕੋਸ਼ ਰੱਖਣਾ ਅਤੇ ਪਰਿਵਰਤਨਾਂ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਲਿਖਣਾ ਜੀਵਨ ਬਚਾਉਂਦਾ ਹੈ।

# ਇਕਾਈਆਂ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਦਸਤਾਵੇਜ਼ ਦਿਓ = {"ਸਪੀਡ": "km/h", "motor_sic": "C", "pressure": "bar"}# ਜੇਕਰ ਲੋੜ ਹੋਵੇ ਤਾਂ ਸਪਸ਼ਟ ਰੂਪਾਂਤਰਨ (km/h -> m/s)df["speed_ms"] = df["ਸਪੀਡ"] / 3.6

ਮਿੰਨੀ ਕੇਸ ਅਧਿਐਨ

ਕੇਸ 1 - describe() ਨਾਲ ਗਲਤੀ ਫੜੀ ਗਈ। ਇੱਕ ਵਿਸ਼ਲੇਸ਼ਕ ਏਆਈ ਤੋਂ ਕੋਡ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਸੀਮਾ ਦਾ ਅੰਦਾਜ਼ਾ ਬਣਾਉਂਦਾ ਹੈ; ਨਤੀਜਾ ਬੇਤੁਕਾ ਉੱਚ ਹੈ. ਜਦੋਂ ਅਸੀਂ describe() ਆਉਟਪੁੱਟ ਨੂੰ ਦੇਖਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਬੈਟਰੀ ਦੀ ਸਮਰੱਥਾ ਕੁਝ ਲਾਈਨਾਂ ਵਿੱਚ Wh ਵਿੱਚ ਅਤੇ ਦੂਜੀਆਂ ਵਿੱਚ kWh ਵਿੱਚ (1000 ਗੁਣਾ ਅੰਤਰ) ਦਰਜ ਕੀਤੀ ਗਈ ਹੈ। ਜਦੋਂ ਯੂਨਿਟ ਨੂੰ ਇਕਸਾਰ ਕਿਸਮ ਵਿੱਚ ਲਿਆਂਦਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਨਤੀਜਾ ਸੁਧਰਦਾ ਹੈ। ਸਿੱਟਾ: ਇੱਕ ਸਧਾਰਨ ਸੰਖੇਪ ਅੰਕੜੇ ਨੇ ਇੱਕ ਮਾੜੀ ਭਵਿੱਖਬਾਣੀ ਨੂੰ ਰੋਕਿਆ।

ਕੇਸ 2 - ਉਲਝਣ ਦਾ ਜਾਲ। ਇੱਕ ਇੰਟਰਨ ਦਾ ਬ੍ਰੇਕ ਵੀਅਰ ਮਾਡਲ ਟੈਸਟ ਸੈੱਟ 'ਤੇ 98% ਸਹੀ ਸੀ। ਜਦੋਂ ਕੋਡ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਹ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿ train_test_split(shuffle=True) ਅਤੇ ਸਮਾਂ ਲੜੀ ਨੂੰ ਮਿਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਭਾਵ ਕਿ ਭਵਿੱਖ ਦੇ ਪੁਆਇੰਟ ਸਿਖਲਾਈ ਵਿੱਚ ਲੀਕ ਹੁੰਦੇ ਹਨ। ਜਦੋਂ ਸਮੇਂ ਦੁਆਰਾ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸ਼ੁੱਧਤਾ 80% ਤੱਕ ਘੱਟ ਜਾਂਦੀ ਹੈ, ਪਰ ਇਹ ਹੁਣ ਯਥਾਰਥਵਾਦੀ ਹੈ। ਸਿੱਟਾ: ਸਿਰਫ਼ ਕਿਉਂਕਿ ਏਆਈ ਕੋਡ ਨੇ ਕੰਮ ਕੀਤਾ, ਇਹ ਸਹੀ ਨਹੀਂ ਸੀ; ਮਨੁੱਖ ਨੇ ਲੀਕ ਨੂੰ ਫੜ ਲਿਆ.

ਕੇਸ 3 - ਆਊਟਲੀਅਰ ਨੂੰ ਸਮਝਣਾ। ਇੱਕ ਟਿਕਾਊਤਾ ਰਿਕਾਰਡ ਵਿੱਚ, AI ਕੋਡ ਆਪਣੇ ਆਪ ਆਊਟਲੀਅਰ ਤਣਾਅ ਮੁੱਲਾਂ ਨੂੰ ਮਿਟਾ ਦਿੰਦਾ ਹੈ। ਇੰਜੀਨੀਅਰ ਮਿਟਾਏ ਗਏ ਬਿੰਦੂਆਂ ਨੂੰ ਦੇਖਦਾ ਹੈ; ਇਹ ਦਰਾੜ ਦੀ ਸ਼ੁਰੂਆਤ ਦੇ ਬਿਲਕੁਲ ਉਹ ਪਲ ਸਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਟੈਸਟ ਦੀ ਦਿਲਚਸਪੀ ਸੀ। ਮਿਟਾਉਣਾ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਉਲੰਘਣਾਵਾਂ ਨੂੰ ਵੱਖਰੀ ਸਮੀਖਿਆ ਵਿੱਚ ਲਿਆ ਜਾਂਦਾ ਹੈ। ਨਤੀਜਾ: "ਸਫ਼ਾਈ" ਦੇ ਤਹਿਤ ਅਸਲ ਸਿਗਨਲ ਨੂੰ ਮਿਟਾ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ; ਹਰ ਕਦਮ 'ਤੇ ਸਵਾਲ.

ਪ੍ਰੋਂਪਟ ਟੈਂਪਲੇਟਸ

ਟੈਮਪਲੇਟ 1 - ਬੇਨਤੀ ਕੋਡ (ਸਪਸ਼ਟੀਕਰਨ ਦੇ ਨਾਲ):

ਭੂਮਿਕਾ: ਤੁਸੀਂ ਪਾਈਥਨ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਕ ਸਲਾਹਕਾਰ ਹੋ। ਕੰਮ: ਕੋਡ ਲਿਖੋ ਜੋ ਇੱਕ ਟੈਲੀਮੈਟਰੀ CSV ਨੂੰ ਲੋਡ ਕਰਦਾ ਹੈ ਅਤੇ ਜਾਂਚਦਾ ਹੈ। ਪ੍ਰਸੰਗ: ਕਾਲਮ: ਸਮਾਂ, ਸਪੀਡ(km/h), engine_sic(C), ਕ੍ਰਾਂਤੀ(rpm)। ਪਾਬੰਦੀ: ਹਰ ਕਤਾਰ ਨੂੰ ਟਿੱਪਣੀ ਕਰੋ; ਦੱਸੋ ਕਿ ਕਿਹੜੀ ਜਾਂਚ ਕੀਤੀ ਗਈ ਸੀ ਅਤੇ ਕਿਉਂ; ਸਰੀਰਕ ਤੌਰ 'ਤੇ ਅਸੰਭਵ ਮੁੱਲ ਜਾਂਚ ਸ਼ਾਮਲ ਕਰੋ; ਚੁੱਪ-ਚਾਪ ਕੁਝ ਨਹੀਂ ਮਿਟਾਉਣਾ। ਆਉਟਪੁੱਟ: ਟਿੱਪਣੀ ਕੋਡ + ਮੈਨੂੰ ਕਿਹੜਾ ਆਉਟਪੁੱਟ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਕਿਉਂ।

ਟੈਮਪਲੇਟ 2 - ਲੀਕ ਨਿਰੀਖਣ:

ਭੂਮਿਕਾ: ਤੁਸੀਂ ਇੱਕ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਕੋਡ ਸਮੀਖਿਅਕ ਹੋ। ਟਾਸਕ: ਡੇਟਾ ਲੀਕ ਲਈ ਹੇਠਾਂ ਦਿੱਤੀ ਸਿਖਲਾਈ/ਟੈਸਟ ਸਪਲਿਟ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰੋ। ਸੰਦਰਭ: ਇਹ ਇੱਕ ਸਮਾਂ ਲੜੀ (ਵਾਹਨ ਟੈਲੀਮੈਟਰੀ) ਹੈ। ਪਾਬੰਦੀ: ਚੇਤਾਵਨੀ ਦਿਓ ਜੇਕਰ ਬੇਤਰਤੀਬੇ ਸ਼ਫਲਿੰਗ ਹੈ; ਸਮੇਂ ਅਨੁਸਾਰ ਵੰਡਣ ਦਾ ਸੁਝਾਅ ਅਤੇ ਜਾਇਜ਼ ਠਹਿਰਾਓ। ਆਉਟਪੁੱਟ: ਖੋਜ + ਸਹੀ ਕੋਡ + ਵਿਆਖਿਆ।

ਟੈਮਪਲੇਟ 3 - ਯੂਨਿਟ ਪ੍ਰਮਾਣਿਕਤਾ:

ਰੋਲ: ਤੁਸੀਂ ਇੱਕ ਡੇਟਾ ਗੁਣਵੱਤਾ ਆਡੀਟਰ ਹੋ। ਕੰਮ: ਜਾਂਚਾਂ ਦਾ ਸੁਝਾਅ ਦਿਓ ਜੋ ਡੇਟਾਫ੍ਰੇਮ ਵਿੱਚ ਯੂਨਿਟ ਅਸੰਗਤਤਾ ਨੂੰ ਵੇਖਦੇ ਹਨ। ਸੰਦਰਭ: ਸਮਰੱਥਾ ਕੁਝ ਕਤਾਰਾਂ ਵਿੱਚ kWh ਅਤੇ ਦੂਜਿਆਂ ਵਿੱਚ Wh ਹੋ ਸਕਦੀ ਹੈ। ਆਉਟਪੁੱਟ: ਕੋਡ + ਸ਼ੱਕੀ ਪੈਟਰਨ ਨੂੰ ਕਿਵੇਂ ਲੱਭਣਾ ਹੈ ਦੀ ਜਾਂਚ ਕਰੋ।

ਟੈਮਪਲੇਟ 4 - ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ + ਟਿੱਪਣੀ:

ਭੂਮਿਕਾ: ਤੁਸੀਂ ਇੱਕ ਡੇਟਾ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਮਾਹਰ ਹੋ। ਕੰਮ: ਕੋਡ ਲਿਖੋ ਜੋ ਇੰਜਣ ਦੇ ਤਾਪਮਾਨ ਦੇ ਕੋਰਸ ਅਤੇ ਵਾਧੇ ਦੀ ਦਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਪਾਬੰਦੀ: ਇਕਾਈ ਦੇ ਨਾਲ ਧੁਰੇ ਨੂੰ ਲੇਬਲ ਕਰੋ; ਦ੍ਰਿਸ਼ਟੀਗਤ ਤੌਰ 'ਤੇ ਵਿਗਾੜ ਨੂੰ ਚਿੰਨ੍ਹਿਤ ਕਰੋ; ਗ੍ਰਾਫ ਦੀ ਵਿਆਖਿਆ ਕਰਦੇ ਸਮੇਂ ਨਿਸ਼ਚਿਤ ਨੁਕਸ ਦਾ ਦਾਅਵਾ ਨਾ ਕਰੋ। ਆਉਟਪੁੱਟ: ਕੋਡ + ਗ੍ਰਾਫ ਵਿੱਚ ਕੀ ਵੇਖਣਾ ਹੈ।

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ:

ਇਸ ਡੇਟਾ ਨਾਲ ਇੱਕ ਮਾਡਲ ਬਣਾਓ।

ਇਹ ਸਪਸ਼ਟ ਨਹੀਂ ਹੈ ਕਿ ਕਿਹੜਾ ਨਿਸ਼ਾਨਾ, ਕਿਹੜਾ ਡੱਬਾ, ਕਿਹੜਾ ਤਸਦੀਕ; AI ਸਕ੍ਰੈਂਬਲਡ, ਲੀਕੀ, ਯੂਨਿਟ-ਬਲਾਈਂਡ ਕੋਡ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰ ਸਕਦਾ ਹੈ।

ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰਾਉਟ:

ਭੂਮਿਕਾ: ਤੁਸੀਂ ਪਾਈਥਨ ML ਸਲਾਹਕਾਰ ਹੋ। ਟਾਸਕ: ਬ੍ਰੇਕ ਪੈਡ ਦੇ ਖਰਾਬ ਹੋਣ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀਆਂ ਕਮੀਆਂ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਨ ਲਈ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਵਰਕਫਲੋ ਲਿਖੋ। ਸੰਦਰਭ: ਸਮਾਂ ਲੜੀ ਟੈਲੀਮੈਟਰੀ; ਟੀਚਾ: ਬਾਕੀ ਪੈਡ ਮੋਟਾਈ। ਸੀਮਾ: ਸਮੇਂ ਦੀ ਲੜੀ ਨੂੰ ਸਮੇਂ ਅਨੁਸਾਰ ਵੰਡੋ (ਕੋਈ ਸ਼ਫਲਿੰਗ ਨਹੀਂ); ਡਾਟਾ ਲੀਕ ਹੋਣ ਦੇ ਜੋਖਮ 'ਤੇ ਫਲੈਗ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ; ਦਸਤਾਵੇਜ਼ ਇਕਾਈਆਂ; ਹਰੇਕ ਕਦਮ ਦੀ ਵਿਆਖਿਆ ਕਰੋ; ਫੀਲਡ ਵਿੱਚ ਨਤੀਜਾ ਆਉਣ ਤੋਂ ਪਹਿਲਾਂ ਲਿਖੋ ਕਿ ਕਿਹੜੀਆਂ ਜਾਂਚਾਂ ਦੀ ਲੋੜ ਹੈ। ਆਉਟਪੁੱਟ: ਟਿੱਪਣੀ ਕੋਡ + ਪੁਸ਼ਟੀਕਰਨ ਚੈੱਕਲਿਸਟ।

ਆਮ ਗਲਤੀਆਂ

• ਕੋਡ ਨੂੰ ਸਮਝੇ ਬਿਨਾਂ ਚਲਾ ਰਿਹਾ ਹੈ। AI ਕੋਡ ਵੀ ਨੁਕਸਦਾਰ ਹੋ ਸਕਦਾ ਹੈ; ਲਾਈਨ ਦਰ ਲਾਈਨ ਪੜ੍ਹੋ.
• ਮਿਕਸਿੰਗ ਟਾਈਮ ਸੀਰੀਜ਼। shuffle=ਸੱਚਾ ਭਵਿੱਖ ਨੂੰ ਲੀਕ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਨਕਲੀ ਸਕੋਰ ਪੈਦਾ ਕਰਦਾ ਹੈ।
• ਅੰਨ੍ਹੇਵਾਹ ਆਊਟਲਾਇਰ ਨੂੰ ਮਿਟਾਓ. ਅਸਲ ਸਿਗਨਲ (ਨੁਕਸ ਦੀ ਸ਼ੁਰੂਆਤ) ਨੂੰ ਸਾਫ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
• ਯੂਨਿਟ ਦਾ ਦਸਤਾਵੇਜ਼ ਨਹੀਂ ਹੈ। ਗਲਤੀਆਂ ਜਿਵੇਂ ਕਿ km/h ਬਨਾਮ m/s, Wh ਬਨਾਮ kWh ਚੁੱਪਚਾਪ ਵਧਦੀਆਂ ਹਨ।
• ਵਰਣਨ()/ਚੈੱਕ ਕਦਮ ਨੂੰ ਛੱਡਣਾ। ਜ਼ਿਆਦਾਤਰ ਤਰੁੱਟੀਆਂ ਪਹਿਲੇ ਸੰਖੇਪ ਅੰਕੜਿਆਂ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੀਆਂ ਹਨ।

ਸੰਖੇਪ ਵਿੱਚ

• ਪਾਈਥਨ (ਪੈਂਡਾ, ਨੰਪੀ, ਮੈਟਪਲੋਟਲਿਬ, ਸਕਿਟ-ਲਰਨ) ਆਟੋਮੋਟਿਵ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਦਾ ਅਸਲ ਮਿਆਰ ਹੈ।
• ਦੁਹਰਾਉਣਯੋਗ ਵਿਸ਼ਲੇਸ਼ਣ: ਲੋਡ ਕਰੋ, ਨਿਰੀਖਣ ਕਰੋ, ਸਾਫ਼ ਕਰੋ, ਵਿਸ਼ੇਸ਼ਤਾ ਕਰੋ, ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ, ਪ੍ਰਮਾਣਿਤ ਕਰੋ ਅਤੇ ਰਿਪੋਰਟ ਕਰੋ।
• ਕੋਡ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਤਸਦੀਕ ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ ਕਿ AI ਲਾਈਨ ਦਰ ਲਾਈਨ ਪੈਦਾ ਕਰਦਾ ਹੈ; ਕਿਉਂਕਿ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਸਹੀ ਹੈ।
• ਸਮਾਂ ਲੜੀ ਵਿੱਚ ਅਤੀਤ/ਭਵਿੱਖ ਦੇ ਅੰਤਰ ਨੂੰ ਬਣਾਈ ਰੱਖਣਾ; ਬੇਤਰਤੀਬ ਸ਼ਫਲਿੰਗ ਡਾਟਾ ਲੀਕ ਬਣਾਉਂਦਾ ਹੈ।
• ਯੂਨਿਟ ਦੀ ਇਕਸਾਰਤਾ ਅਤੇ ਬਾਹਰੀ ਵਿਆਖਿਆ ਚੁੱਪ ਪਰ ਤਸਦੀਕ ਦੇ ਨਾਜ਼ੁਕ ਬਿੰਦੂ ਹਨ।

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

ਇੱਕ ਛੋਟਾ ਡਾਟਾ ਸੈੱਟ ਲਵੋ (ਅਸਲ ਜਾਂ ਸਿੰਥੈਟਿਕ ਟੈਲੀਮੈਟਰੀ)। (1) ਛੇ-ਪੜਾਅ ਵਾਲੇ ਫਰੇਮਵਰਕ ਦੇ ਬਾਅਦ, ਟੈਂਪਲੇਟ 1 ਦੇ ਨਾਲ ਲੋਡਿੰਗ ਅਤੇ ਕੰਟਰੋਲ ਕੋਡ ਤਿਆਰ ਕਰੋ ਅਤੇ ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਤੁਸੀਂ ਹਰ ਲਾਈਨ ਨੂੰ ਸਮਝਦੇ ਹੋ। (2) describe() ਆਉਟਪੁੱਟ ਵਿੱਚ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਸ਼ੱਕੀ ਮੁੱਲ ਲੱਭੋ ਅਤੇ ਜਾਂਚ ਕਰੋ ਕਿ ਕਿਉਂ। (3) ਇੱਕ ਪੂਰਵ-ਅਨੁਮਾਨ ਕਾਰਜ ਵਿੱਚ, ਸਿਖਲਾਈ/ਟੈਸਟ ਦਾ ਸਮਾਂ ਵੰਡੋ ਅਤੇ ਟੈਂਪਲੇਟ 2 ਦੇ ਨਾਲ ਲੀਕ ਹੋਣ ਦੇ ਜੋਖਮ ਦੀ ਜਾਂਚ ਕਰੋ। (4) ਤੁਹਾਡੇ ਦੁਆਰਾ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਹਰੇਕ ਕਾਲਮ ਦੀ ਇਕਾਈ ਨੂੰ ਦਸਤਾਵੇਜ਼ ਬਣਾਓ।

ਚੈੱਕਲਿਸਟ

• [ ] ਮੈਂ ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਛੇ-ਪੜਾਅ ਵਾਲੇ ਫਰੇਮਵਰਕ ਨਾਲ ਸੈਟ ਅਪ ਕੀਤਾ ਹੈ।
• [ ] ਮੈਂ ਏਆਈ ਲਾਈਨ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਪੜ੍ਹਿਆ ਅਤੇ ਸਮਝਿਆ।
• [ ] ਮੈਂ describe()/audit ਨਾਲ ਸ਼ੱਕੀ ਮੁੱਲਾਂ ਦੀ ਭਾਲ ਕੀਤੀ।
• [ ] ਮੈਂ ਸਮੇਂ ਦੀ ਲੜੀ ਨੂੰ ਸਮੇਂ ਅਨੁਸਾਰ ਵੰਡਦਾ ਹਾਂ (ਕੋਈ ਸ਼ਫਲਿੰਗ ਨਹੀਂ)।
• [ ] ਮੈਂ ਉਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਹੈ ਜੋ ਡੇਟਾ ਲੀਕ ਹੋਣ ਦੇ ਜੋਖਮ ਵਿੱਚ ਹਨ।
• [ ] ਮੈਂ ਹਰੇਕ ਕਾਲਮ ਦੀ ਇਕਾਈ ਦਾ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਕੀਤਾ ਹੈ ਅਤੇ ਪਰਿਵਰਤਨਾਂ ਨੂੰ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਹੈ।