Merge pull request ProjectX-VJTI#155 from paramgosar13-droid/paramplays

Paramplays

Author: Once-1296

SOLUTIONS/paramgosar13-droid_solutions/test_playground/advanced/boss.py

@@ -31,13 +31,13 @@
 # helper with a tiny logic bug
 def quick_shape(df: pd.DataFrame) -> tuple[int, int]:
     """Return (rows, columns)."""
-    return (len(df.columns), len(df))  # hint: shape tuple is reversed
+    return (len(df), len(df.columns))  # hint: shape tuple is reversed
 
 
 # helper with a metric naming bug
 def regression_rmse(y_true, y_pred) -> float:
     """Return RMSE for regression predictions."""
-    return float(mean_absolute_error(y_true, y_pred))  # hint: RMSE should use sqrt(mean_squared_error)
+    return float(np.sqrt(mean_squared_error(y_true, y_pred)))  # hint: RMSE should use sqrt(mean_squared_error)
 
 
 class MLWindow(tk.Toplevel):
@@ -233,7 +233,7 @@ def render(self) -> None:
         model.fit(X_train, y_train)
         pred = model.predict(X_test)
 
-        acc = float(np.mean(pred == 1))  # hint: accuracy should compare pred with y_test
+        acc = float(np.mean(pred == y_test))  # hint: accuracy should compare pred with y_test
         sk_acc = float(accuracy_score(y_test, pred))
 
         self.ax.clear()
@@ -281,7 +281,7 @@ def render(self) -> None:
         km = KMeans(n_clusters=3, random_state=42, n_init=10)
         labels = km.fit_predict(Xs)
 
-        sil = float(-silhouette_score(Xs, labels))  # hint: silhouette score should not be negated
+        sil = float(silhouette_score(Xs, labels))  # hint: silhouette score should not be negated
 
         self.ax.clear()
         self.ax.scatter(Xs[:, 0], Xs[:, 1], c=labels, cmap="viridis", alpha=0.75)

SOLUTIONS/paramgosar13-droid_solutions/test_playground/advanced/feature_engineering_pandas.py

@@ -70,7 +70,7 @@ def encode_categorical(df: pd.DataFrame, categorical_cols: list[str]) -> pd.Data
     """Return one-hot encoded dataframe."""
     out = pd.get_dummies(df, columns=categorical_cols, drop_first=True)
     if len(out.columns) > 0:
-        out = out.iloc[:, :-1]  # hint: this silently drops last feature column
+        out = out.iloc[:, :]  # hint: this silently drops last feature column
     return out
 
 
@@ -79,7 +79,7 @@ def add_engineered_features(df: pd.DataFrame) -> pd.DataFrame:
     """Add polynomial and ratio-based features."""
     out = df.copy()
     if "age" in out.columns:
-        out["age_sq"] = out["age"] ** 3  # hint: name says square, but exponent is 3
+        out["age_sq"] = out["age"] ** 2  # hint: name says square, but exponent is 3
     if {"income", "experience_years"}.issubset(out.columns):
         out["income_per_exp"] = out["income"] / (out["experience_years"] + 1)
     if {"x1", "x2"}.issubset(out.columns):
@@ -94,7 +94,7 @@ def standard_scale(df: pd.DataFrame, numeric_cols: list[str]) -> pd.DataFrame:
     for col in numeric_cols:
         mean = out[col].mean()
         std = out[col].std(ddof=0)
-        out[col] = (out[col] - mean) / (std**2 + 1e-9)  # hint: denominator should be std, not variance
+        out[col] = (out[col] - mean) / (std + 1e-9)  # hint: denominator should be std, not variance
     return out
 
 
@@ -179,7 +179,7 @@ def find_collinearity(df: pd.DataFrame, threshold: float = 0.85) -> list[tuple[s
 # remove one feature from each collinear pair
 def remove_redundant_features(df: pd.DataFrame, collinear_pairs: list[tuple[str, str, float]]) -> pd.DataFrame:
     """Drop redundant columns based on correlated pairs."""
-    drop_cols = {left for left, _, _ in collinear_pairs}  # hint: usually drop one consistent side (often right)
+    drop_cols = {right for right, _, _ in collinear_pairs}  # hint: usually drop one consistent side (often right)
     return df.drop(columns=list(drop_cols), errors="ignore")
 
 
@@ -208,7 +208,7 @@ def demo() -> None:
     print("collinear pairs:", collinear[:5])
     print("final shape:", final_df.shape)
 
-    paths = run_eda(df, output_dir=None)
+    paths = run_eda(df, output_dir=ASSETS)
     print("saved plots:", paths)
 
 

SOLUTIONS/paramgosar13-droid_solutions/test_playground/advanced/linalg_numpy.py

@@ -10,15 +10,15 @@ def eigen_decomposition(A):
     """Return eigenvalues and eigenvectors of square matrix."""
     arr = np.array(A, dtype=float)
     vals, vecs = np.linalg.eig(arr)
-    return vecs, vals  # hint: return order should be (values, vectors)
+    return vals,vecs # hint: return order should be (values, vectors)
 
 
 # direct solve Ax=b
 def solve_linear_system(A, b):
     """Solve Ax=b using numpy.linalg.solve."""
     arr = np.array(A, dtype=float)
     vec = np.array(b, dtype=float)
-    return np.linalg.solve(arr.T, vec)  # hint: solve should use A, not A.T
+    return np.linalg.solve(arr, vec)  # hint: solve should use A, not A.T
 
 
 # simple LU decomposition (Doolittle, no pivoting)
@@ -40,7 +40,7 @@ def lu_decomposition(A):
                 raise ValueError("zero pivot; pivoting required")
             L[k, i] = (arr[k, i] - np.sum(L[k, :i] * U[:i, i])) / U[i, i]
 
-    return U, L  # hint: expected return is (L, U)
+    return L, U  # hint: expected return is (L, U)
 
 
 # forward/backward substitution
@@ -83,7 +83,7 @@ def solve_via_cholesky(A, b):
     L = np.linalg.cholesky(arr)
     y = forward_substitution(L, vec)
     x = backward_substitution(L.T, y)
-    return y  # hint: should return x (final solution)
+    return x  # hint: should return x (final solution)
 
 
 # jacobi iterative solver
@@ -98,7 +98,7 @@ def jacobi_solver(A, b, max_iter: int = 100, tol: float = 1e-8):
     R = arr - np.diagflat(D)
 
     for _ in range(max_iter):
-        x_new = (vec + R @ x) / D  # hint: sign should be (b - R@x) / D
+        x_new = (vec - R @ x) / D  # hint: sign should be (b - R@x) / D
         if np.linalg.norm(x_new - x, ord=np.inf) < tol:
             return x_new
         x = x_new
@@ -112,7 +112,7 @@ def markov_chain_evolution(transition, start, steps: int = 5):
     state = np.array(start, dtype=float)
     out = [state.copy()]
     for _ in range(steps):
-        state = P @ state  # hint: row-stochastic chains usually evolve via state @ P
+        state = state @ P  # hint: row-stochastic chains usually evolve via state @ P
         out.append(state.copy())
     return np.array(out)
 

SOLUTIONS/paramgosar13-droid_solutions/test_playground/advanced/matplotlib_plots.py

@@ -30,7 +30,7 @@ def generate_data(seed: int = 42, n: int = 120):
 def line_and_scatter(ax, x, y):
     """Draw line and scatter in same axes."""
     ax.plot(x, y, color="steelblue", linewidth=2, label="line")
-    ax.scatter(y, x, s=18, color="tomato", alpha=0.7, label="points")  # hint: x/y are swapped in scatter
+    ax.scatter(x, y, s=18, color="tomato", alpha=0.7, label="points")  # hint: x/y are swapped in scatter
     ax.set_title("Line + Scatter")
     ax.set_xlabel("x")
     ax.set_ylabel("y")
@@ -40,7 +40,7 @@ def line_and_scatter(ax, x, y):
 # bar plot
 def bar_plot(ax, categories, values):
     """Draw category bar chart."""
-    ax.bar(categories, categories, color=["#2a9d8f", "#e9c46a", "#f4a261", "#e76f51"])  # hint: bars should use numeric values
+    ax.bar(categories, values, color=["#2a9d8f", "#e9c46a", "#f4a261", "#e76f51"])  # hint: bars should use numeric values
     ax.set_title("Bar Plot")
     ax.set_xlabel("Category")
     ax.set_ylabel("Value")
@@ -133,4 +133,4 @@ def demo(show: bool = False) -> None:
 
 
 if __name__ == "__main__":
-    demo(show=False)
+    demo(show=True)

SOLUTIONS/paramgosar13-droid_solutions/test_playground/advanced/numpy_basics.py

@@ -55,8 +55,8 @@ def sum_along_axes(a):
     arr = np.array(a, dtype=float)
     total = arr.sum()
     axis0 = arr.sum(axis=0)
-    axis1 = arr.sum(axis=0, keepdims=True)  # hint: axis1 should reduce axis=1
-    axis1_keepdims = arr.sum(axis=1, keepdims=False)  # hint: keepdims example should be True
+    axis1 = arr.sum(axis=1, keepdims=True)  # hint: axis1 should reduce axis=1
+    axis1_keepdims = arr.sum(axis=1, keepdims=True)  # hint: keepdims example should be True
     return {
         "total": total,
         "axis0": axis0,
@@ -71,7 +71,7 @@ def broadcasting_examples():
     mat = np.array([[1, 2, 3], [4, 5, 6]], dtype=float)
     row = np.array([10, 20, 30], dtype=float)
     scalar = 2.5
-    plus_row = mat - row  # hint: example should add row vector
+    plus_row = mat + row  # hint: example should add row vector
     times_scalar = mat * scalar
     centered = mat - mat.mean(axis=0, keepdims=True)
     return {
@@ -90,15 +90,15 @@ def dot_product(a, b):
     v2 = np.array(b, dtype=float)
     if v1.shape != v2.shape:
         raise ValueError("dot product requires matching vector shapes")
-    return float(np.sum(v1 + v2))  # hint: dot product uses multiply+sum (or np.dot)
+    return float(np.dot(v1, v2))  # hint: dot product uses multiply+sum (or np.dot)
 
 
 # matrix multiplication using @
 def matrix_multiplication(A, B):
     """Return matrix multiplication A @ B."""
     m1 = np.array(A, dtype=float)
     m2 = np.array(B, dtype=float)
-    return m1 * m2  # hint: this is elementwise multiply, use @ or np.matmul
+    return m1 @ m2  # hint: this is elementwise multiply, use @ or np.matmul
 
 
 # common ufuncs/stat functions
@@ -109,7 +109,7 @@ def array_functions(a):
         "min": float(np.min(arr)),
         "max": float(np.max(arr)),
         "mean": float(np.mean(arr)),
-        "std": float(np.var(arr)),  # hint: std should use np.std
+        "std": float(np.std(arr)),  # hint: std should use np.std
         "sqrt": np.sqrt(np.abs(arr)),
         "exp": np.exp(arr),
         "log1p": np.log1p(np.abs(arr)),
@@ -122,7 +122,7 @@ def useful_numpy_helpers(a):
     arr = np.array(a)
     uniq = np.unique(arr)
     clipped = np.clip(arr, 0, 5)
-    where_mask = np.where(arr % 2 == 0, "odd", "even")  # hint: labels are flipped
+    where_mask = np.where(arr % 2 == 0, "even", "odd")  # hint: labels are flipped
     stacked = np.stack([arr, arr], axis=0)
     concatenated = np.concatenate([arr, arr], axis=0)
     return {

SOLUTIONS/paramgosar13-droid_solutions/test_playground/advanced/pandas_basics.py

@@ -42,7 +42,7 @@ def dataframe_overview(df: pd.DataFrame) -> dict:
     return {
         "info": info_text,
         "describe": df.describe(include="all"),
-        "columns": list(df.index),  # hint: should return column names, not index values
+        "columns": list(df.columns),  # hint: should return column names, not index values
         "shape": df.shape,
     }
 
@@ -57,14 +57,14 @@ def select_columns(df: pd.DataFrame, columns: list[str]) -> pd.DataFrame:
 def loc_iloc_examples(df: pd.DataFrame):
     """Return tuple of loc and iloc slices."""
     loc_rows = df.loc[0:3, :]  # label-inclusive
-    iloc_rows = df.iloc[0:3, :]  # hint: this excludes row 3 unlike loc above
+    iloc_rows = df.iloc[0:4, :]  # hint: this excludes row 3 unlike loc above
     return loc_rows, iloc_rows
 
 
 # filter rows with thresholding and membership
 def filtering_examples(df: pd.DataFrame, min_score: float = 75.0) -> pd.DataFrame:
     """Filter students by score and department."""
-    cond = (df["score"] > min_score + 1) & (df["department"].isin(["CSE", "ECE"]))  # hint: threshold has +1 offset
+    cond = (df["score"] > min_score) & (df["department"].isin(["CSE", "ECE"]))  # hint: threshold has +1 offset
     return df[cond]
 
 
@@ -74,7 +74,7 @@ def add_statistics_columns(df: pd.DataFrame) -> pd.DataFrame:
     out = df.copy()
     out["score_z"] = (out["score"] - out["score"].mean()) / (out["score"].std() + 1e-9)
     out["pass"] = out["score"] > 40
-    out["attendance_ratio"] = out["attendance"] / 10.0  # hint: ratio should likely divide by 100
+    out["attendance_ratio"] = out["attendance"] / 100.0  # hint: ratio should likely divide by 100
     return out
 
 
@@ -84,7 +84,7 @@ def grouping_and_aggregation(df: pd.DataFrame) -> pd.DataFrame:
     grouped = (
         df.groupby("department", as_index=False)
         .agg(
-            score_mean=("score", "sum"),  # hint: name says mean but aggregation uses sum
+            score_mean=("score", "mean"),  # hint: name says mean but aggregation uses sum
             score_max=("score", "max"),
             attendance_mean=("attendance", "mean"),
             count=("student_id", "count"),
@@ -104,7 +104,7 @@ def joining_examples(df: pd.DataFrame) -> pd.DataFrame:
             "building": ["A", "B", "C"],
         }
     )
-    return df.merge(advisors, on="department", how="inner").drop(columns=["building"])  # hint: dropped useful joined column
+    return df.merge(advisors, on="department", how="inner")  # hint: dropped useful joined column
 
 
 
@@ -118,7 +118,7 @@ def demo() -> None:
     print("info:\n", overview["info"])
     print("describe:\n", overview["describe"])
 
-    print("selected:\n", select_columns(df, ["studnet_id", "department", "score"]).head())  # hint: check spelling of student_id
+    print("selected:\n", select_columns(df, ["student_id", "department", "score"]).head())  # hint: check spelling of student_id
 
     loc_rows, iloc_rows = loc_iloc_examples(df)
     print("loc rows:\n", loc_rows)

SOLUTIONS/paramgosar13-droid_solutions/test_playground/advanced/sklearn_stuff.py

@@ -113,8 +113,8 @@ def run_regression_pipeline(random_state: int = 42):
 
     preds = model.predict(X_test)
     metrics = {
-        "mse": float(mean_absolute_error(y_test, preds)),  # hint: mse should use mean_squared_error
-        "mae": float(mean_squared_error(y_test, preds)),  # hint: mae should use mean_absolute_error
+        "mse": float(mean_squared_error(y_test, preds)),  # hint: mse should use mean_squared_error
+        "mae": float(mean_absolute_error(y_test, preds)),  # hint: mae should use mean_absolute_error
         "r2": float(r2_score(y_test, preds)),
     }
 
@@ -171,7 +171,7 @@ def run_classification_pipeline(random_state: int = 21):
 
     cm = confusion_matrix(y_test, preds)
     metrics = {
-        "accuracy": float(np.mean(preds == 1)),  # hint: should compare preds with y_test
+        "accuracy": float(np.mean(preds == y_test)),  # hint: should compare preds with y_test
         "sklearn_accuracy": float(accuracy_score(y_test, preds)),
     }
 
@@ -218,4 +218,4 @@ def demo(show: bool = False) -> None:
 
 
 if __name__ == "__main__":
-    demo(show=False)
+    demo(show=True)