Python for Financial AI

import pandas as pd
data = pd.read_csv("sp500_jan2022.csv")
jan3 = data[data['Date'] == '2022-01-03']
top_stock = jan3.sort_values('Volume', ascending=False).iloc[0]
print(f"Highest volume: {top_stock['Symbol']} at {top_stock['Volume']:,.0f} shares")

import pandas as pd

# Load data
data = pd.read_csv("messy_stocks.csv")

# Cleanse
clean_data = data.dropna()
clean_data['Date'] = pd.to_datetime(clean_data['Date'])
clean_data.set_index('Date', inplace=True)

# Calculate
clean_data['20D_Vol'] = clean_data['Close'].pct_change().rolling(20).std()

print(clean_data.head())

import yfinance as yf
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

# Get data
tsla = yf.download("TSLA", start="2022-01-01", end="2023-01-01")

# Calculate RSI
delta = tsla['Close'].diff()
gain = delta.where(delta > 0, 0)
loss = -delta.where(delta < 0, 0)
avg_gain = gain.rolling(14).mean()
avg_loss = loss.rolling(14).mean()
rs = avg_gain / avg_loss
tsla['RSI'] = 100 - (100 / (1 + rs))

# Create figure
fig = plt.figure(figsize=(14,10))
gs = GridSpec(2, 1, height_ratios=[3,1])

# Price chart
ax1 = fig.add_subplot(gs[0])
ax1.plot(tsla['Close'], label='Price', color='black')
ax1.plot(tsla['Close'].rolling(10).mean(), label='10D MA', color='blue')
ax1.plot(tsla['Close'].rolling(30).mean(), label='30D MA', color='red')
ax1.set_title('TSLA 2022 - Price with Moving Averages')
ax1.legend()

# RSI chart
ax2 = fig.add_subplot(gs[1], sharex=ax1)
ax2.plot(tsla['RSI'], color='purple')
ax2.axhline(70, color='red', linestyle='--')
ax2.axhline(30, color='green', linestyle='--')
ax2.set_title('RSI (14)')

plt.tight_layout()
plt.show()

# Moving Average Sharpe
ma_sharpe = (0.12 - 0.02) / 0.08  # = 1.25

# Momentum Sharpe
mom_sharpe = (0.18 - 0.02) / 0.22  # = 0.73

"""
The Moving Average strategy has better risk-adjusted returns 
(Sharpe 1.25 vs 0.73) and much smaller drawdowns (-15% vs -35%).
Unless you have iron nerves, MA is the wiser choice.
"""

import yfinance as yf
import numpy as np
from sklearn.linear_model import LinearRegression

# Get data
metals = yf.download(["GC=F", "SI=F"], start="2020-01-01")['Adj Close']
returns = metals.pct_change().dropna()

# Regression
model = LinearRegression()
model.fit(returns["GC=F"].values.reshape(-1,1), returns["SI=F"])
print(f"Silver moves {model.coef_[0]:.2f}x Gold daily")

# Simulation
def simulate(S0, mu, sigma, days=252, sims=10000):
    daily_ret = np.random.normal(mu/days, sigma/np.sqrt(days), (days, sims))
    return S0 * (1 + daily_ret).cumprod(axis=0)

gold_paths = simulate(1800, 0.08, 0.15)
silver_paths = simulate(25, 0.12, 0.25)

import yfinance as yf
from statsmodels.tsa.arima.model import ARIMA

# Get data
eth = yf.download("ETH-USD", period="2y")['Close']

# Fit model (after testing p,d,q)
model = ARIMA(eth, order=(2,1,2))
results = model.fit()

# Forecast
forecast = results.forecast(steps=7)
print(f"Next week's ETH forecast:\n{forecast}")

import yfinance as yf
from sklearn.ensemble import RandomForestClassifier

# Get data
data = yf.download("SPY", period="5y")

# Feature engineering
data['5D_MA'] = data['Close'].rolling(5).mean()
data['20D_MA'] = data['Close'].rolling(20).mean()
# ... (add 8 more features)

# Prepare model
features = data.dropna().iloc[:, 5:-1]  # All features
target = (data['Close'].shift(-1) > data['Close']).astype(int).dropna()

model = RandomForestClassifier(n_estimators=200)
model.fit(features, target)

# Strategy: Buy when prediction > 0.6

import backtrader as bt
import backtrader.analyzers as btanalyzers

class GoldenCrossStrategy(bt.Strategy):
    params = (
        ('fast', 50),
        ('slow', 200),
        ('printlog', False),
    )
    
    def __init__(self):
        self.fast_ma = bt.indicators.SMA(period=self.p.fast)
        self.slow_ma = bt.indicators.SMA(period=self.p.slow)
        self.crossover = bt.indicators.CrossOver(self.fast_ma, self.slow_ma)
    
    def next(self):
        if not self.position:
            if self.crossover > 0:
                self.buy()
        elif self.crossover < 0:
            self.close()
    
    def stop(self):
        if self.p.printlog:
            print('Final Portfolio Value: %.2f' % self.broker.getvalue())

# Create cerebro engine
cerebro = bt.Cerebro()

# Add data feed
data = bt.feeds.YahooFinanceData(dataname='SPY', fromdate=datetime(2010, 1, 1),
                                todate=datetime(2020, 12, 31))
cerebro.adddata(data)

# Add strategy
cerebro.addstrategy(GoldenCrossStrategy, printlog=True)

# Set commission
cerebro.broker.setcommission(commission=0.001)  # 0.1% commission

# Add analyzers
cerebro.addanalyzer(btanalyzers.SharpeRatio, _name='sharpe')
cerebro.addanalyzer(btanalyzers.DrawDown, _name='drawdown')

# Run backtest
results = cerebro.run()

# Print results
print('Sharpe Ratio:', results[0].analyzers.sharpe.get_analysis()['sharperatio'])
print('Max Drawdown:', results[0].analyzers.drawdown.get_analysis()['max']['drawdown'])

import backtrader as bt
import numpy as np

class RiskManagedStrategy(bt.Strategy):
    params = (
        ('stop_loss', 0.02),  # 2% stop-loss
        ('max_position', 0.1),  # 10% max position
    )
    
    def next(self):
        # Position sizing
        cash = self.broker.getcash()
        value = self.broker.getvalue()
        max_size = value * self.p.max_position / self.data.close[0]
        
        if not self.position:
            if self.should_buy():  # Your buy signal
                self.buy(size=max_size)
        else:
            # Stop-loss check
            if self.data.close[0] < self.position.price * (1 - self.p.stop_loss):
                self.close()
    
    def stop(self):
        # Calculate portfolio VaR
        returns = np.array([t.pnlcomm for t in self.trades]) / np.array([t.value for t in self.trades])
        var_95 = np.percentile(returns, 5)
        print(f"95% Trade VaR: {var_95:.2%}")

import alpaca_trade_api as tradeapi
import pandas as pd
import matplotlib.pyplot as plt
from IPython.display import clear_output

# Initialize Alpaca API
api = tradeapi.REST('YOUR_API_KEY', 'YOUR_SECRET_KEY', base_url='https://paper-api.alpaca.markets')

class LiveTrader:
    def __init__(self):
        self.portfolio = {}
        self.history = pd.DataFrame()
        
    def fetch_data(self, symbol):
        bars = api.get_barset(symbol, 'minute', limit=1000).df[symbol]
        return bars
    
    def generate_signals(self, data):
        # Implement your strategy here
        signals = your_strategy(data)
        return signals
    
    def execute_trades(self, signals):
        for symbol, signal in signals.items():
            if signal == 'BUY':
                api.submit_order(
                    symbol=symbol,
                    qty=100,
                    side='buy',
                    type='market',
                    time_in_force='gtc'
                )
            elif signal == 'SELL':
                api.submit_order(
                    symbol=symbol,
                    qty=100,
                    side='sell',
                    type='market',
                    time_in_force='gtc'
                )
    
    def monitor(self):
        while True:
            clear_output(wait=True)
            account = api.get_account()
            print(f"Equity: ${account.equity}")
            print(f"Buying Power: ${account.buying_power}")
            
            # Update portfolio
            positions = api.list_positions()
            for pos in positions:
                self.portfolio[pos.symbol] = {
                    'qty': pos.qty,
                    'value': pos.market_value,
                    'pnl': pos.unrealized_pl
                }
            
            # Plot portfolio
            plt.figure(figsize=(10,5))
            pd.DataFrame.from_dict(self.portfolio, orient='index')['value'].plot(kind='bar')
            plt.title('Portfolio Allocation')
            plt.show()
            
            time.sleep(60)

# Run the trader
trader = LiveTrader()
trader.monitor()