Update app.py

Author: Hariprashad-Ravikumar

backend/app.py

@@ -8,6 +8,7 @@
 from flask import Flask, request, jsonify, send_file
 from flask_cors import CORS
 from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
 import numpy as np
 import openai
 from datetime import datetime
@@ -17,81 +18,87 @@
 # === CONFIG ===
 BACKEND_BASE_URL = "https://ai-dslab-backend-cpf2feachnetbbck.westus-01.azurewebsites.net"
 
-# Initialize Flask app
 app = Flask(__name__)
-CORS(app)  # Enable CORS for all routes
+CORS(app)
 
-# Use a secure temporary directory
 TEMP_DIR = tempfile.TemporaryDirectory()
 UPLOAD_FOLDER = TEMP_DIR.name
 PLOT_PATH = os.path.join(UPLOAD_FOLDER, "plot.png")
+FORECAST_PLOT_PATH = os.path.join(UPLOAD_FOLDER, "forecast_plot.png")
+REPORT_PATH = os.path.join(UPLOAD_FOLDER, "summary_report.txt")
 
-# Cleanup temp directory on shutdown
 @atexit.register
 def cleanup_temp_dir():
     TEMP_DIR.cleanup()
 
-# Capture logs
 log_stream = io.StringIO()
 
 def log_print(*args):
     print(*args, file=log_stream)
     sys.stdout.flush()
 
-# Root route for health check
 @app.route("/")
 def index():
-    return jsonify({"message": "✅ AI DataScience Backend is running on Azure."})
+    return jsonify({"message": "AI DataScience Backend is running on Azure."})
 
-# Handle file upload and processing
 @app.route("/upload", methods=["POST"])
 def upload_file():
     log_stream.truncate(0)
     log_stream.seek(0)
 
     file = request.files.get("file")
-    if file is None:
-        return jsonify({"error": "No file uploaded"}), 400
+    x_col = request.form.get("x_column")
+    y_col = request.form.get("y_column")
+    model_choice = request.form.get("model", "linear")
+
+    if file is None or not x_col or not y_col:
+        return jsonify({"error": "Missing file or column selection."}), 400
 
     filepath = os.path.join(UPLOAD_FOLDER, file.filename)
     file.save(filepath)
-    log_print("📦 File uploaded:", file.filename)
-
     df = pd.read_csv(filepath)
-    df.dropna(inplace=True)
+
+    if x_col not in df.columns or y_col not in df.columns:
+        return jsonify({"error": f"'{x_col}' or '{y_col}' not in dataset."}), 400
+
+    df = df[[x_col, y_col]].dropna()
     df.columns = ['X', 'Y']
-    log_print("🔍 Cleaned Data:", df.head())
+    log_print("Cleaned Data:\n", df.head())
 
-    # Plot
+    # Scatter plot
     plt.figure()
     plt.scatter(df['X'], df['Y'])
     plt.xlabel('X')
     plt.ylabel('Y')
     plt.title('Scatter Plot')
     plt.savefig(PLOT_PATH)
     plt.close()
-    log_print("📊 Scatter plot saved.")
 
-    # Fit model
-    df['X'] = pd.to_datetime(df['X'], errors='coerce')
-    df.dropna(inplace=True)
-    X = df['X'].map(pd.Timestamp.toordinal).values.reshape(-1, 1)
-    y = df['Y'].values
-
-    if len(X) == 0:
-        log_print("❌ No valid data to fit the model.")
-        return jsonify({
-            "summary": "No valid data found.",
-            "log": log_stream.getvalue(),
-            "forecast": "N/A",
-            "plot_url": None
-        })
+    # Try parsing X as datetime
+    df['X_date'] = pd.to_datetime(df['X'], errors='coerce')
+    use_dates = df['X_date'].notna().sum() >= len(df) // 2
+    try:
+        if use_dates:
+            df = df.dropna(subset=['X_date'])
+            X = df['X_date'].map(pd.Timestamp.toordinal).values.reshape(-1, 1)
+        else:
+            X = df['X'].astype(float).values.reshape(-1, 1)
+        y = df['Y'].astype(float).values
+    except:
+        return jsonify({"error": "Failed to parse X or Y as numeric or date."}), 400
+
+    if model_choice == "linear":
+        model = LinearRegression()
+    else:
+        return jsonify({"error": "Only linear regression supported for now."}), 400
 
-    model = LinearRegression()
     model.fit(X, y)
-    log_print("🤖 Model trained.")
+    y_pred = model.predict(X)
+    r2 = r2_score(y, y_pred)
+    mse = mean_squared_error(y, y_pred)
+    log_print(f"Model Trained. R² = {r2:.4f}, MSE = {mse:.4f}")
 
-    # OpenAI summary
+    # OpenAI Summary
     try:
         openai.api_key = os.getenv("OPENAI_API_KEY")
         client = openai.OpenAI(api_key=openai.api_key)
@@ -103,81 +110,118 @@ def upload_file():
             ]
         )
         summary = response.choices[0].message.content
-        log_print("🧠 OpenAI Summary generated.")
+        log_print("Summary generated by OpenAI.")
     except Exception as e:
         summary = "OpenAI summarization failed."
-        log_print("❌ OpenAI error:", str(e))
+        log_print("OpenAI error:", str(e))
 
     return jsonify({
         "summary": summary,
         "log": log_stream.getvalue(),
-        "forecast": "Submit future x-values below to get predictions.",
+        "forecast": "Submit future values below to get predictions.",
+        "r2_score": round(r2, 4),
+        "mse": round(mse, 4),
         "plot_url": f"{BACKEND_BASE_URL}/plot.png"
     })
 
-# Serve the generated plot
-@app.route("/plot.png")
-def serve_plot():
-    return send_file(PLOT_PATH, mimetype="image/png")
-
-# Handle prediction requests
 @app.route("/predict", methods=["POST"])
 def predict():
     future_x = request.form.get("future_x")
     if not future_x:
-        return jsonify({
-            "forecast": "No future values provided.",
-            "log": log_stream.getvalue(),
-            "plot_url": None
-        })
+        return jsonify({"forecast": "No future values provided."}), 400
 
     try:
-        values = [datetime.strptime(x.strip(), "%Y-%m-%d").toordinal()
-                  for x in future_x.split(",")]
-    except ValueError:
-        log_print("❌ Invalid date format. Use YYYY-MM-DD.")
-        return jsonify({
-            "forecast": "Invalid date format. Use YYYY-MM-DD.",
-            "log": log_stream.getvalue(),
-            "plot_url": None
-        })
+        values = future_x.split(",")
+        numeric_vals, date_vals = [], []
+        for x in values:
+            try:
+                date_vals.append(datetime.strptime(x.strip(), "%Y-%m-%d").toordinal())
+            except:
+                numeric_vals.append(float(x.strip()))
+        values_parsed = np.array(date_vals if date_vals else numeric_vals).reshape(-1, 1)
+    except Exception as e:
+        log_print("Parsing future_x failed:", str(e))
+        return jsonify({"forecast": "Invalid format for future values."}), 400
 
     try:
         files = os.listdir(UPLOAD_FOLDER)
-        if not files:
-            raise FileNotFoundError("No uploaded file found.")
-        latest_file = max(
+        csv_file = max(
             [os.path.join(UPLOAD_FOLDER, f) for f in files if f.endswith(".csv")],
             key=os.path.getctime
         )
-        df = pd.read_csv(latest_file)
-        df.dropna(inplace=True)
+        df = pd.read_csv(csv_file)
+        df = df.dropna()
         df.columns = ['X', 'Y']
-        df['X'] = pd.to_datetime(df['X'], errors='coerce')
-        df.dropna(inplace=True)
-        X = df['X'].map(pd.Timestamp.toordinal).values.reshape(-1, 1)
-        y = df['Y'].values
+        df['X_date'] = pd.to_datetime(df['X'], errors='coerce')
+        use_dates = df['X_date'].notna().sum() >= len(df) // 2
+
+        if use_dates:
+            df = df.dropna(subset=['X_date'])
+            X = df['X_date'].map(pd.Timestamp.toordinal).values.reshape(-1, 1)
+        else:
+            X = df['X'].astype(float).values.reshape(-1, 1)
+        y = df['Y'].astype(float).values
 
         model = LinearRegression()
         model.fit(X, y)
 
-        predicted = model.predict(np.array(values).reshape(-1, 1))
+        y_future = model.predict(values_parsed)
         result = {
-            datetime.fromordinal(v).strftime("%Y-%m-%d"): round(p, 2)
-            for v, p in zip(values, predicted)
+            (datetime.fromordinal(int(x)) if use_dates else float(x)): round(p, 2)
+            for x, p in zip(values_parsed.flatten(), y_future)
         }
 
-        log_print("🔮 Forecast complete.")
+        # Generate second plot
+        X_all = np.concatenate((X, values_parsed))
+        x_min, x_max = X_all.min(), X_all.max()
+        x_plot = np.linspace(x_min, x_max, 200).reshape(-1, 1)
+        y_plot = model.predict(x_plot)
+
+        plt.figure()
+        plt.scatter(X, y, label='Training Data', alpha=0.6)
+        plt.plot(x_plot, y_plot, color='blue', label='Regression Line')
+        plt.scatter(values_parsed, y_future, color='red', label='Forecast', marker='x')
+        plt.legend()
+        plt.xlabel('X')
+        plt.ylabel('Y')
+        plt.title('Forecast with Regression Line')
+        plt.savefig(FORECAST_PLOT_PATH)
+        plt.close()
+
+        # Write report
+        with open(REPORT_PATH, 'w') as f:
+            f.write("AI Forecast Report\\n")
+            f.write("=================\\n\\n")
+            f.write("Model: Linear Regression\\n")
+            f.write(f"R² Score: {r2_score(y, model.predict(X)):.4f}\\n")
+            f.write(f"MSE: {mean_squared_error(y, model.predict(X)):.4f}\\n")
+            f.write("\\nForecast Results:\\n")
+            for k, v in result.items():
+                f.write(f"{k}: {v}\\n")
+
         return jsonify({
-            "forecast": result,
+            "forecast": {str(k): v for k, v in result.items()},
             "log": log_stream.getvalue(),
-            "plot_url": f"{BACKEND_BASE_URL}/plot.png"
+            "plot_url": f"{BACKEND_BASE_URL}/plot.png",
+            "forecast_plot_url": f"{BACKEND_BASE_URL}/forecast_plot.png"
         })
 
     except Exception as e:
-        log_print("❌ Prediction failed:", str(e))
+        log_print("Prediction failed:", str(e))
         return jsonify({
             "forecast": "Prediction failed.",
             "log": log_stream.getvalue(),
             "plot_url": None
         })
+
+@app.route("/plot.png")
+def serve_plot():
+    return send_file(PLOT_PATH, mimetype="image/png")
+
+@app.route("/forecast_plot.png")
+def serve_forecast_plot():
+    return send_file(FORECAST_PLOT_PATH, mimetype="image/png")
+
+@app.route("/download-report", methods=["GET"])
+def download_report():
+    return send_file(REPORT_PATH, as_attachment=True, download_name="report.txt")