future-cash-flow-model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "source": [
    "%pip install pandas -U -q\n",
    "%pip install numpy -U -q\n",
    "%pip install plotly -U -q\n",
    "%pip install nbformat -U -q\n",
    "%pip install scikit-learn -U -q\n",
    "%pip install seaborn -q\n",
    "%pip install matplotlib -q\n",
    "%pip install pickle -U -q"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Análise exploratório dos dados de fluxo de caixa das empresas brasileiras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "source": [
    "import pandas as pd\n",
    "\n",
    "predicted_cash_flow_components = pd.read_csv(\"./assets/predicted_cash_flow_components.csv\", header=[0, 1], index_col=0)\n",
    "predicted_cash_flow_components"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "source": [
    "df = predicted_cash_flow_components[\"VALE3.SA\"].dropna().transpose()\n",
    "df"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "source": [
    "X_cashflow = df.iloc[:, 1:4]\n",
    "y_cashflow = df.iloc[:, 0]"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "source": [
    "X_cashflow.shape"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Previsão do fluxo de caixa livre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import r2_score, mean_absolute_error\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "def train_model_and_predict(model, X, y):\n",
    "  X_scaler = MinMaxScaler()\n",
    "  X_scaled = X_scaler.fit_transform(X.reshape(-1, 1))\n",
    "\n",
    "  y_scaler = MinMaxScaler()\n",
    "  y_scaled = y_scaler.fit_transform(y.reshape(-1, 1))\n",
    "\n",
    "  model.fit(X_scaled, y_scaled.ravel())\n",
    "  predictions = model.predict(X_scaled)\n",
    "\n",
    "  predictions_real_scale = y_scaler.inverse_transform(predictions.reshape(-1, 1))\n",
    "  return predictions_real_scale\n",
    "\n",
    "def score_model(y_real, y):\n",
    "  try:\n",
    "    r2 = r2_score(y_real, y)\n",
    "    mae = mean_absolute_error(y_real, y)\n",
    "  except:\n",
    "    r2 = 0.0\n",
    "    mae = 0.0\n",
    "  \n",
    "  print(f\"Coeficiente de determinação (R^2): {r2}\") # Quanto mais próximo de 1, melhor é o modelo\n",
    "  print(f\"Erro médio absoluto (MAE): {mae:,.2f}\") # Quanto menor o valor, melhor é o modelo\n",
    "\n",
    "  return r2, mae\n",
    "\n",
    "def combine_attributes(df, y_column_name, model):\n",
    "  correlation_matrix = df.corr()[y_column_name]\n",
    "\n",
    "  # Filtra os atributos com correlação >= 70%\n",
    "  high_corr = correlation_matrix[correlation_matrix >= 0.7].iloc[1:]\n",
    "\n",
    "  # Atributos com correlação forte com a coluna \"y_column\"\n",
    "  X_columns_name = high_corr.sort_values().index.to_list()\n",
    "  X_columns_index = [df.columns.get_loc(column) for column in X_columns_name]\n",
    "\n",
    "  y_attribute = df.iloc[:, df.columns.get_loc(y_column_name)].values\n",
    "  predictions = {}\n",
    "\n",
    "  for name, index in zip(X_columns_name, X_columns_index):\n",
    "    X_attribute = df.iloc[:, index].values\n",
    "\n",
    "    prediction = train_model_and_predict(model, X_attribute, y_attribute)\n",
    "    predictions.update({f\"{name} X {y_column_name}\": prediction.ravel()})\n",
    "\n",
    "  df = pd.DataFrame(predictions)\n",
    "  df[\"Mean\"] = df.mean(axis=1)\n",
    "  \n",
    "  return df\n",
    "  "
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regressão linear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "cash_flow_linear_regressor = LinearRegression()\n",
    "df_predictions = combine_attributes(df, \"Free Cash Flow\", cash_flow_linear_regressor)\n",
    "df_predictions"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "source": [
    "score_model(df.iloc[:, 0], df_predictions[\"Mean\"])"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Redes neurais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "source": [
    "from sklearn.neural_network import MLPRegressor\n",
    "\n",
    "cash_flow_mlp_regressor = MLPRegressor(hidden_layer_sizes=(100, 50), max_iter=1000, random_state=0)\n",
    "df_predictions = combine_attributes(df, \"Free Cash Flow\", cash_flow_linear_regressor)\n",
    "df_predictions"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "source": [
    "score_model(df.iloc[:, 0], df_predictions[\"Mean\"])"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testar com outras ações"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "source": [
    "unique_tickers = set(ticker for ticker, _ in brazilian_companies_cashflow.columns)\n",
    "tickers = list(unique_tickers)\n",
    "tickers"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "source": [
    "cash_flow_linear_regressor = LinearRegression()\n",
    "r2_scores = []\n",
    "\n",
    "for ticker in tickers:\n",
    "  df = predicted_cash_flow_components[ticker].dropna().transpose()\n",
    "  \n",
    "  df_predictions = combine_attributes(df, \"Free Cash Flow\", cash_flow_linear_regressor)\n",
    "\n",
    "  print(f\"{'-' * 20} {ticker} {'-' * 20}\")\n",
    "  r2, _ = score_model(df.iloc[:, 0], df_predictions[\"Mean\"])\n",
    "\n",
    "  r2_scores.append(r2)\n",
    "\n",
    "print(f\"\\n\\nCoeficiente de determinação (R^2) médio: {np.mean(r2_scores)}\")"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outra abordagem de previsão de fluxo de caixa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "source": [
    "from typing import List, Tuple\n",
    "from pandas import DataFrame\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import r2_score, mean_absolute_error\n",
    "\n",
    "\n",
    "def standardization(df: DataFrame, X_columns: List[str], y_column: str) -> Tuple[any, any, any, any]:\n",
    "    X_index = [df.columns.get_loc(column) for column in X_columns]\n",
    "\n",
    "    X_real = df.iloc[:, X_index]\n",
    "    X_scaler = MinMaxScaler()\n",
    "    X_scaled = X_scaler.fit_transform(X_real)\n",
    "\n",
    "    y_real = df[y_column]\n",
    "    y_scaler = MinMaxScaler()\n",
    "    y_scaled = y_scaler.fit_transform(y_real.reshape(-1, 1))\n",
    "\n",
    "    return X_real, X_scaled, y_real, y_scaled\n",
    "\n",
    "\n",
    "def predict_free_cash_flow(components: DataFrame) -> DataFrame:\n",
    "    X_data = components.iloc[:, 1:]\n",
    "    y_data = components.iloc[:, 0]\n",
    "\n",
    "    if \"Free Cash Flow\" not in components.columns:\n",
    "        raise Exception(\"DataFrame has no 'Free Cash Flow' column.\")\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X_data, y_data, random_state=0)\n",
    "    \n",
    "    poly = PolynomialFeatures(degree=4)\n",
    "    X_train_poly = poly.fit_transform(X_train)\n",
    "    X_test_poly = poly.transform(X_test)\n",
    "\n",
    "    polynomial_regression = LinearRegression()\n",
    "    polynomial_regression.fit(X_train_poly, y_train)\n",
    "    predictions = polynomial_regression.predict(X_test_poly)\n",
    "\n",
    "    print(\"-\" * 50)\n",
    "    score_train = polynomial_regression.score(X_train_poly, y_train)\n",
    "    print(f\"Train score: {score_train * 100:.2f}%\")\n",
    "\n",
    "    score_test = polynomial_regression.score(X_test_poly, y_test)\n",
    "    print(f\"Train score: {score_test * 100:.2f}%\")\n",
    "\n",
    "    r2 = r2_score(y_test, predictions)\n",
    "    print(f\"Coeficiente de determinação (R^2): {r2}\") # Quanto mais próximo de 1, melhor é o modelo\n",
    "\n",
    "    mae = mean_absolute_error(y_test, predictions)\n",
    "    print(f\"Erro médio absoluto (MAE): {mae:,.2f}\") # Quanto menor o valor, melhor é o modelo\n",
    "    print(\"-\" * 50)"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "source": [
    "components = predicted_cash_flow_components.transpose()\n",
    "\n",
    "X_data = components.iloc[:, 1:]\n",
    "y_data = components.iloc[:, 0]"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "source": [
    "X_data.shape, y_data.shape"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "source": [
    "predict_free_cash_flow(components)"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Salvar modelo já treinado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "source": [
    "import pickle\n",
    "from pathlib import Path\n",
    "\n",
    "models_dir = Path(\"models\")\n",
    "\n",
    "if not models_dir.exists():\n",
    "  models_dir.mkdir()\n",
    "\n",
    "pickle.dump(cash_flow_linear_regressor, open('models/future_cash_flow_model.sav', 'wb'))\n"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "source": [],
   "outputs": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}