DAILY NEWS

Stay Ahead, Stay Informed – Every Day

Advertisement
TECH & AI
How to Price Options at the Institutional Level Using AI (PINNs) and Python
jackminion 0



If you work or study the derivatives market, you know that speed and accuracy in calculating options prices are not just technical goals — they are competitive differentiators. Traditionally, we rely on the Black-Scholes model or Monte Carlo simulations structured in legacy code to approximate the fair price of a contract. However, when we need to scale these calculations to thousands of simultaneous requests or handle complex boundary conditions, processing bottlenecks appear. This is where the fusion between Artificial Intelligence and Financial Physics comes in: PINNs (Physics-Informed Neural Networks). In this article, I will show you how to consume an institutional-grade infrastructure based on physics-informed neural networks to price options in milliseconds using Python. What are PINNs and why do they matter in finance?Unlike traditional neural networks that need billions of historical data to “learn” a trend (and that often fail when trying to extrapolate), PINNs integrate mathematical laws directly into their loss function. mathematical hallucinations and we achieve absurdly fast inference power, ideal for high-frequency systems (HFT) and real-time risk management. Hands-on: Consuming PINN Master in PythonTo avoid having to assemble, train and host a cluster of GPUs to run this network from scratch, we will use PINN Master – Institutional Option Pricing, a robust API hosted in AZURE that exposes this model ready for production. Best of all? It has a 100% free tier for testing. Step 1: Get your credentialsBefore running the script, you just need to access the official PINN Master page on RapidAPI and subscribe to the free plan to release your access token. If you have any questions about getting started, there is a very simple to follow Official PINN Master Startup Tutorial. Step 2: The CodeWith your key in hand, use the code below to make a call to price a call: import requests # High performance API endpoint url = “https://pinn-master-institutional-option-pricing.p.rapidapi.com/v1/price” # Contract pricing parameters querystring = { “spot”: “100.0”, # Current price of the underlying asset “strike”: “100.0”, # Option strike price “volatility”: “0.20”, # Implied volatility (20%) “rate”: “0.05”, # Risk-free interest rate (5%) “maturity”: “1.0”, # Time to expiration (1 year) “type”: “call” # Contract type: call or put } headers = { “X-RapidAPI-Key”: “YOUR_FREE_CHAVE_AQUI”, “X-RapidAPI-Host”: “pinn-master-institutional-option-pricing.p.rapidapi.com” } try: response = requests.get(url, headers=headers, params=querystring) response.raise_for_status() dados_precificacao = response.json() print(“— PINN Master Invocation Result —“) print(dados_precificacao) except requests.exceptions.RequestException as e: print(f”Error connecting to quant infrastructure: {e}”) Enter fullscreen mode Exit fullscreen mode Why is this approach a game changer? Predictable Latency: By transferring the complexity of the mathematical calculation to an optimized neural network inference in the cloud, you gain homogeneous response time. Infrastructure Abstraction: The entire scalability architecture in AZURE is hidden behind a clean GET method. Easy Integration: You can plug this return directly into trading dashboards, dynamic spreadsheets or order execution bots.



Source link

TECH & AI
Anatomy of Duck DB for Python Developers
jackminion 0



Introduction – SQL without a Server

Pandas is widely used for data analysis and almost every data analyst or even data engineers utilize it for faster analysis with table like data structure called DataFrames.The drawback is that it suffers once the data goes beyond few GB’s and spinning up a Postgres or a Redshift is an overkill for quick analysis.Duck DB fills this gap with Zero-setup columnar SQL.

Getting Started – zero config, instant power

DuckDb is an open source OLAP database management system designed for analytics and for running within the same process as the application.It is lightweight, can work directly with data files in csv, parquet etc without needing a server.

Installation and first query

pip install duckdb – No ports to open, No configuration and No daemon

In-Memory and Persistent Database – Two Operating Modes

In-MemoryWhen DuckDB connection is created without specifying a file, a database lives entirely in RAM.

import duckdb
con = duckdb.connect() # or duckdb.connect(‘:memory:’)

Enter fullscreen mode

Exit fullscreen mode

All data is stored in RAM and no files are written to disk
Extremely fast reads/writes since there is zero I/O overhead.
Data is completely lost when connection closes.
No file locking or concurrency concerns

Persistent ModeWhen the user provides a location DuckDB can write the results to disk in .duckDb format.

con = duckdb.connect(‘my_database.duckdb’)

Enter fullscreen mode

Exit fullscreen mode

Tables,Schemas and indexes are persisted.
Uses a columnar storage format with compression and buffered I/O
Only one write connection at a time but multiple read connection are allowed.
Supports WAL(Write Ahead Logging) for crash recovery

Powerful Pattern

DuckDb allows you to mix both modes where user can start with in-memory and attach a persistent database or use copy/export to snapshot in-memory result to disk.

con = duckdb.connect()

#Query a CSV, transform it, save the result to a persistent file
con.execute(“””
COPY(SELECT region, SUM(sales) AS total FROM read_csv(‘data.csv’)
GROUP BY region
)
TO ‘results.parquet’ (FORMAT PARQUET)
“””)

Enter fullscreen mode

Exit fullscreen mode

Users gets the speed of In-Memory processing which accelerates the pipeline processing with an option to persist.

Reading files directly –CSV,PARQUET,JSON,Arrow,

Query CSV without loading into memory

Select * from read_csv(‘data_csv’, auto_detect=true);

Enter fullscreen mode

Exit fullscreen mode

-Auto detects delimiter, compression and data types-Handles malformed rows gracefully-Can read multiple CSVs at once read_csv(‘data/*.csv’)

Parquet

Select * from read_parquet(‘data.parquet’);
–even from S3 directly
Select * from read_parquet(‘s3://bucket/data/*.parquet’);

Enter fullscreen mode

Exit fullscreen mode

Exploits column pruning as it only reads columns you need
Leverages row group skipping using Parquet’s build in min/max stats
Native support for nested types(structs,list,maps)

JSON/NDJSON

SELECT * FROM read_json(‘events.ndjson’, auto_detect=true);

Enter fullscreen mode

Exit fullscreen mode

-AUTO INFERS schema from data-NDJSON(Newline delimited) streams efficiently line by line-Can unnest deeply nested JSON fields using DuckDB’s json_extract, UNNEST, or -> operators

Apache Arrow

import pyarrow as pa
arrow_table = pa.Table.from_pandas(df)
duckdb.query(“”SELECT * from arrow_table”””)

Enter fullscreen mode

Exit fullscreen mode

-Zero copy integration: DuckDB reads from Arrow memory without serialization-Ideal for pipelines where data never needs to touch disk

SQL Beyond Select

DuckDB is not just a query engine, it supports rich SQL that covers data transformation, creation, and some genuinely unique syntax extensions to available in most databases.

Full Suite of WINDOW Functions

Select
customer,
ordered_at,
amount,

— Running total
SUM(amount) OVER (PARTITION BY customer ORDER BY ordered_at) AS running_tot,

— Lag/lead comparisons
LAG(amount) OVER (PARTITION BY customer ORDER BY ordered_at) AS prev_amt,

— Percentile rank
PERCENT_RANK() OVER (ORDER BY amount) AS pct_rank,

— Named window reuse
FIRST_VALUE(amount) OVER w AS first_order
FROM orders
WINDOW w AS (PARTITION BY customer ORDER BY ordered_at);

Enter fullscreen mode

Exit fullscreen mode

DuckDB also allows the use of qualify clause which filters on window result without a subquery.

Select * From orders
QUALIFY ROW_NUMBER() OVER (PARTITION BY customer ORDER BY amount DESC) = 1;

Enter fullscreen mode

Exit fullscreen mode

PIVOT and UNPIVOT

Most databases make you write case when manually for PIVOTS.DuckDB does it natively.

–PIVOT- rows to columns
PIVOT orders on region USING SUM(amount) GROUP BY year;

–UNPIVOT- Column to rows
UNPIVOT sales_wide ON(q1,q2,q3,q4) INTO NAME quarter VALUE revenue;

Enter fullscreen mode

Exit fullscreen mode

MULTI DATABASE SQL

–Attach another DuckDB file
ATTACH ‘archive.duckdb’ AS archive;

— Cross-database join
SELECT a.*, b.region
FROM main.orders a
JOIN archive.customers b ON a.customer_id = b.id;

–Attach another database
ATTACH ‘postgres://user:pass@host/db’ AS pg (TYPE POSTGRES);
SELECT * FROM pg.public.users LIMIT 10;

Enter fullscreen mode

Exit fullscreen mode

DUCKDB+Pandas+Polars –Choosing your stack

DuckDB does not replace pandas or Polars it solves a problem which is niche.The sweet spot of the industry is to use DuckDB for SQL-shaped operations and pandas/polars for row level python logic.

Where Duck DB shines

Feature Engineering for ML: Window functions or group by’s for feature computation are often faster and more readable in DuckDB then pandas before handing it over to Sklearn or pytorch
Unit testing DBT models locally:DuckDB lets you run complete dbt project locally without a cloud warehouse providing fast feedback loop for data engineers.
Light weight ETL Pipelines: One can read raw parquet from S3, transform with SQL, write cleaned output back without any spark cluster or airflow jobs.

Conclusion

DuckDB lets you think in SQL for analytical tasks without worrying about infrastructure setup. Anyone using python can utilize duckdb for analysis of larger files where regular pandas will give headache.Given the advantages, it is important to know whare DuckDB should not be used which in case of concurrent writes,OLTP workloads and long running multi user services.

Reference-https://duckdb.org/docs/current/data/overview



Source link