diff --git a/aion/utils.py b/aion/utils.py new file mode 100644 index 0000000..d7921cd --- /dev/null +++ b/aion/utils.py @@ -0,0 +1,10 @@ +import torch + + +def to(x, device='cuda'): + def _move(x): + if isinstance(x, torch.Tensor): + return x.to(device) + return x + + return torch.utils._pytree.tree_map(_move, x) diff --git a/examples/getting_started.ipynb b/examples/getting_started.ipynb new file mode 100644 index 0000000..abd9678 --- /dev/null +++ b/examples/getting_started.ipynb @@ -0,0 +1,1648 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3c0bc240-a054-47f3-bc6c-d6caada072d8", + "metadata": {}, + "source": [ + "# An Introduction to AION\n", + "\n", + "Jeff Shen ()\n", + "\n", + "7 April 2025" + ] + }, + { + "cell_type": "markdown", + "id": "c703c9f2-c38f-4644-b606-f1471656d6dd", + "metadata": {}, + "source": [ + "
\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "071e0751-def6-4e53-a013-f320084d0f9d", + "metadata": {}, + "source": [ + "## First, an overview. \n", + "\n", + "AION consists of _tokenizers_ and a transformer encoder-decoder processor. The tokenizers are responsible for converting pixel-level data (images, spectra, ...) into _tokens_ which are standardized in format. The transformer is then responsible for modelling all the joint and conditional distributions of these tokens. Any input tokens will go through the encoder part and end up as _embeddings_ (some useful representation of the input data), which go into the decoder along with specified output modalities, to produce output tokens. " + ] + }, + { + "cell_type": "markdown", + "id": "af318246-a71b-470d-9d14-7ccb7eb48739", + "metadata": {}, + "source": [ + "### There are a few common things that you might want to do with AION. \n", + "\n", + "Here I will demonstrate:\n", + "- model loading\n", + "- tokenization\n", + "- sampling\n", + "- embedding-based adaptation" + ] + }, + { + "cell_type": "markdown", + "id": "6d8490ef-fe9c-4dd0-92f9-8262ac210be3", + "metadata": {}, + "source": [ + "
\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "32d32f07-716f-4095-a332-f2a8e042f597", + "metadata": {}, + "source": [ + "## Model loading" + ] + }, + { + "cell_type": "markdown", + "id": "ede15a09-b090-4079-931b-36df079b7074", + "metadata": {}, + "source": [ + "You will need to install the `AION` package from https://github.com/PolymathicAI/AION." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dec3946f-5148-4d27-a439-d96f0a6f96ee", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from aion import AION" + ] + }, + { + "cell_type": "markdown", + "id": "25e15614-85c6-4a61-885a-bf3ddaf297b9", + "metadata": {}, + "source": [ + "Let's load the pretrained model. \n", + "\n", + "__Note__: this only loads the transformer, NOT the tokenizers." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c9792b75-9cb1-49fa-b4ca-1841f65f9785", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading weights from local directory\n" + ] + } + ], + "source": [ + "model = AION.from_pretrained('/mnt/ceph/users/polymathic/aion/dec24/base')" + ] + }, + { + "cell_type": "markdown", + "id": "6e7077f6-c57a-417b-81d4-4cc474a4a8d7", + "metadata": {}, + "source": [ + "### AION transformer\n", + "\n", + "Now, we have access to the transformer model.\n", + "\n", + "There are a few parts to this: the encoder embeddings, encoder, decoder embeddings, and decoder.\n", + "\n", + "The encoder embeddings are responsible for taking the tokens from ints to vectors in a high dimensional space. The encoder processes these vectors and turns them into useful representations. From there, the decoder takes those input representations and gives you representations for the modalities you want. The decoder embeddings then turn those back into ints that you can decode back to pixel-level data. Let's look at some of these parts here." + ] + }, + { + "cell_type": "markdown", + "id": "fde12d34-d9c8-4434-afb4-26a7649ac103", + "metadata": {}, + "source": [ + "Below are all the modalities that AION understands (i.e., is pretrained with):" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6b741b09-d068-40c5-b23d-14c8bc56f57d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "odict_keys(['catalog', 'tok_a_g', 'tok_a_i', 'tok_a_r', 'tok_a_y', 'tok_a_z', 'tok_dec', 'tok_ebv', 'tok_flux_bp_gaia', 'tok_flux_g', 'tok_flux_g_gaia', 'tok_flux_i', 'tok_flux_r', 'tok_flux_rp_gaia', 'tok_flux_w1', 'tok_flux_w2', 'tok_flux_w3', 'tok_flux_w4', 'tok_flux_z', 'tok_image', 'tok_image_hsc', 'tok_mag_g', 'tok_mag_i', 'tok_mag_r', 'tok_mag_y', 'tok_mag_z', 'tok_parallax', 'tok_ra', 'tok_segmap', 'tok_shape11', 'tok_shape12', 'tok_shape22', 'tok_shape_e1', 'tok_shape_e2', 'tok_shape_r', 'tok_spectrum_desi', 'tok_spectrum_sdss', 'tok_xp_bp', 'tok_xp_rp', 'tok_z'])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.encoder_embeddings.keys()" + ] + }, + { + "cell_type": "markdown", + "id": "96968480-e4b1-46f5-aac2-7d7fe4a5cd33", + "metadata": {}, + "source": [ + "And let's take a quick look at the components of the decoder:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "93157a3d-bc8a-4cf5-955c-71ac8245a3ce", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ModuleList(\n", + " (0-11): 12 x DecoderBlock(\n", + " (norm1): LayerNorm()\n", + " (self_attn): NormAttention(\n", + " (qkv): Linear(in_features=768, out_features=2304, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=768, out_features=768, bias=False)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (q_norm): LayerNorm()\n", + " (k_norm): LayerNorm()\n", + " )\n", + " (cross_attn): NormCrossAttention(\n", + " (q): Linear(in_features=768, out_features=768, bias=False)\n", + " (kv): Linear(in_features=768, out_features=1536, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=768, out_features=768, bias=False)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (q_norm): LayerNorm()\n", + " (k_norm): LayerNorm()\n", + " )\n", + " (query_norm): LayerNorm()\n", + " (context_norm): LayerNorm()\n", + " (drop_path): Identity()\n", + " (norm2): LayerNorm()\n", + " (mlp): GatedMlp(\n", + " (fc1): Linear(in_features=768, out_features=2048, bias=False)\n", + " (act): SiLU()\n", + " (fc2): Linear(in_features=2048, out_features=768, bias=False)\n", + " (fc3): Linear(in_features=768, out_features=2048, bias=False)\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.decoder" + ] + }, + { + "cell_type": "markdown", + "id": "7e7be0d1-5dc8-41e4-90d1-67db930c4ac1", + "metadata": {}, + "source": [ + "### Model freezing" + ] + }, + { + "cell_type": "markdown", + "id": "69d2c3c5-a04a-4fca-b04e-498ec5631eb8", + "metadata": {}, + "source": [ + "Here I will not be doing any fine tuning of the actual transformer. So I will freeze all the components. I will also put the model on GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9398e0f0-bed3-4bfb-9424-355aded7e6f8", + "metadata": {}, + "outputs": [], + "source": [ + "model.freeze_encoder(freeze_embeddings=True)\n", + "model.freeze_decoder(freeze_embeddings=True)\n", + "\n", + "model = model.cuda().eval()" + ] + }, + { + "cell_type": "markdown", + "id": "bb9f33ee-7752-45af-bd9c-b40af384067f", + "metadata": {}, + "source": [ + "## Tokenizer loading\n", + "\n", + "_If you are only working at the token level, you can skip this step._\n", + "\n", + "We also need to load the tokenizers to work with raw pixel-level data. For this demo, I will use spectra, and so I will load the spectrum tokenizer. In general, you will need to load the tokenizer for each of the modalities you want to work with. \n", + "\n", + "### TODO: make tokenizer loading easier (I don't want to have to hunt for the path)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cc2a13e8-5c91-4acf-853b-665e78e591b7", + "metadata": {}, + "outputs": [], + "source": [ + "from aion.tokenizers import load_tokenizer\n", + "from aion.utils import to" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a1280b27-ffad-406b-a383-35ea66f2a339", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/home/jshen/miniconda3/envs/mmoma/lib/python3.10/site-packages/torch/package/package_importer.py:235: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " dtype = storage_type.dtype\n" + ] + } + ], + "source": [ + " # for DESI spectra\n", + "tokenizer_spec = load_tokenizer(\n", + " \"/mnt/ceph/users/polymathic/MMOMA/outputs/mmoma_codec_sdss+desi/6kzi0iz9/checkpoints/last.pt\", \n", + " device='cuda'\n", + ")\n", + "\n", + "# for Gaia XP spectra\n", + "tokenizer_bp = load_tokenizer(\n", + " \"/mnt/ceph/users/polymathic/mmoma/outputs/mmoma_codec_parallax_1024/bp_coefficients_codec.pt\",\n", + " device='cpu',\n", + ")\n", + "tokenizer_rp = load_tokenizer(\n", + " \"/mnt/ceph/users/polymathic/mmoma/outputs/mmoma_codec_parallax_1024/rp_coefficients_codec.pt\",\n", + " device='cpu'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f167d06e-76ff-4e31-953b-0ca5c57c361f", + "metadata": {}, + "source": [ + "
\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "461376a9-3214-4d41-885b-fea872e17328", + "metadata": {}, + "source": [ + "## Tokenization\n", + "\n", + "Since AION's transformer works at the token level, we need to give it inputs it understands. Here I will show how you can turn raw (pixel-level) data to tokens." + ] + }, + { + "cell_type": "markdown", + "id": "1d5e9e00-5afe-4791-b3b9-cd3e5f906f5f", + "metadata": {}, + "source": [ + "### Data loading\n", + "\n", + "Ok, let's get some data to play with. For this example I will use low-res spectra (in the form of basis coefficients) from _Gaia_ and medium-res spectra from DESI, but it doesn't matter where you get your data from, as long as it is formatted in the right way. I will not talk about that too much here because it is different for each modality; you will need to check the specifications of the tokenizers to how they need their inputs formatted." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "acb190fb-7f9e-4e39-ae8f-807efe17baf7", + "metadata": {}, + "outputs": [], + "source": [ + "from mmoma.datasets.astropile import CrossMatchedAstroPileLoader\n", + "from mmoma.datasets.preprocessing import PadSpectra\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7f67952f-2fa6-49e3-a0df-0f541aaeeaf0", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf6ea30a80de4590bf50434d8ee73782", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Resolving data files: 0%| | 0/61 [00:00\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "0e42c677-76bf-48db-bcc0-dc94b375f489", + "metadata": {}, + "source": [ + "## Sampling\n", + "\n", + "Here I will demonstrate __sampling__. That is, given some input modality $x$ and some desired output modality $y$, I will draw samples from the conditional distribution $p(y|x)$.\n", + "\n", + "More concretely, I will demonstrate spectrum super-resolution: given (the basis coefficients of) a low-res spectrum from _Gaia_, I will generate (samples of) the corresponding high-res spectrum from DESI. You can use the same strategy to sample from modalities that AION understands, and can even do things like cross-modal generation (e.g., from an image to a spectrum).\n", + "\n", + "We first need to initialize a sampler object" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5e7867e6-95ba-4aca-a2b3-80844433275f", + "metadata": {}, + "outputs": [], + "source": [ + "from aion.fourm.generate import GenerationSampler, build_chained_generation_schedules, init_empty_target_modality, init_full_input_modality\n", + "from aion.fourm.modality_info import MODALITY_INFO" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "e7f5b6c0-1583-466a-b256-2bbf68b81d47", + "metadata": {}, + "outputs": [], + "source": [ + "sampler = GenerationSampler(model)" + ] + }, + { + "cell_type": "markdown", + "id": "3224f4ff-0754-401f-98a7-052c896ddc03", + "metadata": {}, + "source": [ + "Then we set up the generation by specifying the input and output modalities. The modalities that the model understands are from the `model.encoder_embeddings.keys()` from above. We also need to specify how many tokens the target modality has. Since I am generating `tok_spectrum_desi`, if we remember from above, this has 273 tokens (the sequence length)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "912cd242-04cb-4394-8e72-8341cc9b7293", + "metadata": {}, + "outputs": [], + "source": [ + "input_mod = ['tok_xp_bp', 'tok_xp_bp']\n", + "target_mod = ['tok_spectrum_desi']\n", + "tokens_per_target = [273]" + ] + }, + { + "cell_type": "markdown", + "id": "d001f19d-16e3-420e-b466-d56447506173", + "metadata": {}, + "source": [ + "### Setting up the inputs\n", + "We then prepare the inputs into a dictionary where each modality gets a key, and the corresponding value contains another dictionary with the actual tokens, and an input and output mask." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "73df935c-831a-49f8-b3fe-58b3afaf3d4d", + "metadata": {}, + "outputs": [], + "source": [ + "device = 'cuda' # where to run the model\n", + "\n", + "prepared_input_tokens = dict(\n", + " tok_xp_bp=tok_bp,\n", + " tok_xp_rp=tok_rp,\n", + ")\n", + "\n", + "batched_sample = {\n", + " k: dict(\n", + " tensor=v.to(device).int(),\n", + " input_mask=torch.zeros_like(v, dtype=torch.bool, device=device), # False = used as input, True = ignored\n", + " target_mask=torch.ones_like(v, dtype=torch.bool, device=device), # False = predicted as target, True = ignored\n", + " ) for k, v in prepared_input_tokens.items()\n", + "}\n", + "\n", + "# Initialize input modalities\n", + "for im in input_mod:\n", + " batched_sample = init_full_input_modality(batched_sample, MODALITY_INFO, im, device)\n", + "\n", + "for tm, ntoks in zip(target_mod, tokens_per_target):\n", + " batched_sample = init_empty_target_modality(batched_sample, MODALITY_INFO, tm, batched_sample[im]['tensor'].shape[0], ntoks, device)" + ] + }, + { + "cell_type": "markdown", + "id": "bc79354f-625e-497f-af88-81436a9d69a6", + "metadata": {}, + "source": [ + "### Setting up the sampler\n", + "\n", + "We need to set up the sampling schedule so that the sampler knows how we want to generate the output tokens." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "84551162-b07d-4015-a918-0a55e992283c", + "metadata": {}, + "outputs": [], + "source": [ + "schedule = build_chained_generation_schedules(\n", + " cond_domains=input_mod, \n", + " target_domains=target_mod, \n", + " tokens_per_target=tokens_per_target, \n", + "\n", + " # for args below, you will need one list item per target modality. here that is just 1\n", + " \n", + " autoregression_schemes=['roar'], # roar, autoregressive, maskgit\n", + " decoding_steps=[25], # how many steps to decode all the tokens\n", + " token_decoding_schedules=['linear'], # constant, linear\n", + " temps=[0.4], # sampling temperature, higher=more diversity\n", + " temp_schedules=['constant'], # constant, linear\n", + " cfg_scales=[1.0], # for classifier free guidance\n", + " cfg_schedules=['constant'],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e1ae32b0-da04-45d8-bde2-f7acb8fb9eeb", + "metadata": {}, + "source": [ + "Now we are ready to do actual sampling! Note that the sampler will overwrite the input dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "aecb6832-faac-4d4c-a83c-c76f58b72080", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25it [00:07, 3.37it/s]\n" + ] + } + ], + "source": [ + "batched_sample = sampler.generate(batched_sample, schedule, verbose=True, seed=0)" + ] + }, + { + "cell_type": "markdown", + "id": "e29574fb-95ba-4372-99c9-e457ca5d765d", + "metadata": {}, + "source": [ + "### Decoding and checking\n", + "\n", + "Ok, now that we have our sampled tokens, we want to see what they look like. To do this, we will decode them back to pixel-level spectra and plot them. Again, we use the tokenizer for this." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "f55b244d-1e16-4e30-89ab-309aee269f5e", + "metadata": {}, + "outputs": [], + "source": [ + "out_tok = batched_sample['tok_spectrum_desi']['tensor'] # grab the actual output tokens that we sampled\n", + "\n", + "with torch.no_grad():\n", + " out_spec = to(tokenizer_spec.decode(out_tok, ctx=dict(spectrum=to(batch['desi_spectrum'], \"cuda\"))), \"cpu\") # decode" + ] + }, + { + "cell_type": "markdown", + "id": "c1821183-65d8-4c4f-bc1d-285feb6dfffd", + "metadata": {}, + "source": [ + "Now let's compare the sampled spectra to the real spectra!" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4277d4a8-f682-4f80-8fea-d6eeb9714d91", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Flux')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ix = 0\n", + "mask = batch['desi_spectrum']['lambda'][ix] < 99999\n", + "plt.plot(batch['desi_spectrum']['lambda'][ix][mask], batch['desi_spectrum']['flux'][ix][mask], label='Truth')\n", + "plt.plot(batch['desi_spectrum']['lambda'][ix][mask], out_spec['spectrum']['flux'][ix][mask], label='Sampled')\n", + "plt.legend(fontsize=12)\n", + "plt.xlabel(\"Wavelength (Ã…)\")\n", + "plt.ylabel(\"Flux\")" + ] + }, + { + "cell_type": "markdown", + "id": "06b2d1f5-6f6a-4748-be8b-f2e7322382a8", + "metadata": {}, + "source": [ + "Congrats, you successfully super-resolved some spectra!" + ] + }, + { + "cell_type": "markdown", + "id": "9426122e-45c4-475c-a713-30e0c0d71148", + "metadata": {}, + "source": [ + "
\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "31a03412-c316-471a-ad77-4616158e1f36", + "metadata": {}, + "source": [ + "## Embedding-based adaptation\n", + "\n", + "Next, I will demonstrate how you can quickly adapt AION to perform downstream tasks based on embeddings. Here I will demonstrate parameter regression for stars.\n", + "\n", + "The idea is that AION has been pretrained on vast amounts of data and has a good general understanding of stars. So, despite not being explicitly told anything about physical parameters, if we give it some input data, at the end of the encoder (we will not be using the decoder here), we will have some useful representation (embeddings) in which \"important\" information about stars is linearly accessible. We will take advantage of this fact to build a simple projection matrix to access this information and to tie it to some physical properties." + ] + }, + { + "cell_type": "markdown", + "id": "0206e165-5ea5-4a57-b9c3-1748af9baa4c", + "metadata": {}, + "source": [ + "### Data\n", + "\n", + "Here I will be using _Gaia_ XP coefficients again as the inputs, and as outputs some stellar parameters. Let's first get the data to train on. We will use the STARHORSE catalog which provides estimates for stellar parameters for APOGEE stars. Let's download it:" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "id": "6a2d799a-1431-44bc-a65a-91a720775597", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "04/07 13:10:05 [\u001b[1;32mNOTICE\u001b[0m] Downloading 1 item(s)\n", + "\u001b[35m[\u001b[0m#cc2e5e 275MiB/275MiB\u001b[36m(99%)\u001b[0m CN:1 DL:\u001b[32m27MiB\u001b[0m\u001b[35m]\u001b[0m\u001b[0m0m\u001b[35m]\u001b[0m\u001b[0mm\n", + "04/07 13:10:17 [\u001b[1;32mNOTICE\u001b[0m] Download complete: /mnt/ceph/users/jshen/programs/AION/examples/APOGEE_DR17_EDR3_STARHORSE_v2.fits\n", + "\n", + "Download Results:\n", + "gid |stat|avg speed |path/URI\n", + "======+====+===========+=======================================================\n", + "cc2e5e|\u001b[1;32mOK\u001b[0m | 24MiB/s|/mnt/ceph/users/jshen/programs/AION/examples/APOGEE_DR17_EDR3_STARHORSE_v2.fits\n", + "\n", + "Status Legend:\n", + "(OK):download completed.\n" + ] + } + ], + "source": [ + "!wget \"https://data.sdss.org/sas/dr17/env/APOGEE_STARHORSE/APOGEE_DR17_EDR3_STARHORSE_v2.fits\"" + ] + }, + { + "cell_type": "markdown", + "id": "0672ce54-a3c0-470c-92c1-a7c081e1fc24", + "metadata": {}, + "source": [ + "Now let's load the data and extract the IDs of the stars for cross matching with Gaia and also extract the target labels we want to predict. Here that will be median estimates for Teff, logg, and [M/H]." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "d9bd208e-d5f3-45e1-84a4-e4d913f160f3", + "metadata": {}, + "outputs": [], + "source": [ + "from astropy.table import Table\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "6e898d37-f4af-4644-8789-8c0daf674d45", + "metadata": {}, + "outputs": [], + "source": [ + "t = Table.read(\"APOGEE_DR17_EDR3_STARHORSE_v2.fits\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "b311c888-dda5-4ea8-b23b-0cc77e7e4cdc", + "metadata": {}, + "outputs": [], + "source": [ + "starhorse_ids = np.array(t['EDR3_source_id']).astype(int)\n", + "targets = np.array(t[['teff50', 'logg50', 'met50']]).view(\"#sk-container-id-2 {\n", + " /* Definition of color scheme common for light and dark mode */\n", + " --sklearn-color-text: black;\n", + " --sklearn-color-line: gray;\n", + " /* Definition of color scheme for unfitted estimators */\n", + " --sklearn-color-unfitted-level-0: #fff5e6;\n", + " --sklearn-color-unfitted-level-1: #f6e4d2;\n", + " --sklearn-color-unfitted-level-2: #ffe0b3;\n", + " --sklearn-color-unfitted-level-3: chocolate;\n", + " /* Definition of color scheme for fitted estimators */\n", + " --sklearn-color-fitted-level-0: #f0f8ff;\n", + " --sklearn-color-fitted-level-1: #d4ebff;\n", + " --sklearn-color-fitted-level-2: #b3dbfd;\n", + " --sklearn-color-fitted-level-3: cornflowerblue;\n", + "\n", + " /* Specific color for light theme */\n", + " --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n", + " --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n", + " --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n", + " --sklearn-color-icon: #696969;\n", + "\n", + " @media (prefers-color-scheme: dark) {\n", + " /* Redefinition of color scheme for dark theme */\n", + " --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n", + " --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n", + " --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n", + " --sklearn-color-icon: #878787;\n", + " }\n", + "}\n", + "\n", + "#sk-container-id-2 {\n", + " color: var(--sklearn-color-text);\n", + "}\n", + "\n", + "#sk-container-id-2 pre {\n", + " padding: 0;\n", + "}\n", + "\n", + "#sk-container-id-2 input.sk-hidden--visually {\n", + " border: 0;\n", + " clip: rect(1px 1px 1px 1px);\n", + " clip: rect(1px, 1px, 1px, 1px);\n", + " height: 1px;\n", + " margin: -1px;\n", + " overflow: hidden;\n", + " padding: 0;\n", + " position: absolute;\n", + " width: 1px;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-dashed-wrapped {\n", + " border: 1px dashed var(--sklearn-color-line);\n", + " margin: 0 0.4em 0.5em 0.4em;\n", + " box-sizing: border-box;\n", + " padding-bottom: 0.4em;\n", + " background-color: var(--sklearn-color-background);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-container {\n", + " /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n", + " but bootstrap.min.css set `[hidden] { display: none !important; }`\n", + " so we also need the `!important` here to be able to override the\n", + " default hidden behavior on the sphinx rendered scikit-learn.org.\n", + " See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n", + " display: inline-block !important;\n", + " position: relative;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-text-repr-fallback {\n", + " display: none;\n", + "}\n", + "\n", + "div.sk-parallel-item,\n", + "div.sk-serial,\n", + "div.sk-item {\n", + " /* draw centered vertical line to link estimators */\n", + " background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n", + " background-size: 2px 100%;\n", + " background-repeat: no-repeat;\n", + " background-position: center center;\n", + "}\n", + "\n", + "/* Parallel-specific style estimator block */\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item::after {\n", + " content: \"\";\n", + " width: 100%;\n", + " border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n", + " flex-grow: 1;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel {\n", + " display: flex;\n", + " align-items: stretch;\n", + " justify-content: center;\n", + " background-color: var(--sklearn-color-background);\n", + " position: relative;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item {\n", + " display: flex;\n", + " flex-direction: column;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item:first-child::after {\n", + " align-self: flex-end;\n", + " width: 50%;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item:last-child::after {\n", + " align-self: flex-start;\n", + " width: 50%;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item:only-child::after {\n", + " width: 0;\n", + "}\n", + "\n", + "/* Serial-specific style estimator block */\n", + "\n", + "#sk-container-id-2 div.sk-serial {\n", + " display: flex;\n", + " flex-direction: column;\n", + " align-items: center;\n", + " background-color: var(--sklearn-color-background);\n", + " padding-right: 1em;\n", + " padding-left: 1em;\n", + "}\n", + "\n", + "\n", + "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n", + "clickable and can be expanded/collapsed.\n", + "- Pipeline and ColumnTransformer use this feature and define the default style\n", + "- Estimators will overwrite some part of the style using the `sk-estimator` class\n", + "*/\n", + "\n", + "/* Pipeline and ColumnTransformer style (default) */\n", + "\n", + "#sk-container-id-2 div.sk-toggleable {\n", + " /* Default theme specific background. It is overwritten whether we have a\n", + " specific estimator or a Pipeline/ColumnTransformer */\n", + " background-color: var(--sklearn-color-background);\n", + "}\n", + "\n", + "/* Toggleable label */\n", + "#sk-container-id-2 label.sk-toggleable__label {\n", + " cursor: pointer;\n", + " display: block;\n", + " width: 100%;\n", + " margin-bottom: 0;\n", + " padding: 0.5em;\n", + " box-sizing: border-box;\n", + " text-align: center;\n", + "}\n", + "\n", + "#sk-container-id-2 label.sk-toggleable__label-arrow:before {\n", + " /* Arrow on the left of the label */\n", + " content: \"â–¸\";\n", + " float: left;\n", + " margin-right: 0.25em;\n", + " color: var(--sklearn-color-icon);\n", + "}\n", + "\n", + "#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {\n", + " color: var(--sklearn-color-text);\n", + "}\n", + "\n", + "/* Toggleable content - dropdown */\n", + "\n", + "#sk-container-id-2 div.sk-toggleable__content {\n", + " max-height: 0;\n", + " max-width: 0;\n", + " overflow: hidden;\n", + " text-align: left;\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-toggleable__content.fitted {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-toggleable__content pre {\n", + " margin: 0.2em;\n", + " border-radius: 0.25em;\n", + " color: var(--sklearn-color-text);\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-toggleable__content.fitted pre {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-fitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n", + " /* Expand drop-down */\n", + " max-height: 200px;\n", + " max-width: 100%;\n", + " overflow: auto;\n", + "}\n", + "\n", + "#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n", + " content: \"â–¾\";\n", + "}\n", + "\n", + "/* Pipeline/ColumnTransformer-specific style */\n", + "\n", + "#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " color: var(--sklearn-color-text);\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "/* Estimator-specific style */\n", + "\n", + "/* Colorize estimator box */\n", + "#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-label label.sk-toggleable__label,\n", + "#sk-container-id-2 div.sk-label label {\n", + " /* The background is the default theme color */\n", + " color: var(--sklearn-color-text-on-default-background);\n", + "}\n", + "\n", + "/* On hover, darken the color of the background */\n", + "#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {\n", + " color: var(--sklearn-color-text);\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "/* Label box, darken color on hover, fitted */\n", + "#sk-container-id-2 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n", + " color: var(--sklearn-color-text);\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "/* Estimator label */\n", + "\n", + "#sk-container-id-2 div.sk-label label {\n", + " font-family: monospace;\n", + " font-weight: bold;\n", + " display: inline-block;\n", + " line-height: 1.2em;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-label-container {\n", + " text-align: center;\n", + "}\n", + "\n", + "/* Estimator-specific */\n", + "#sk-container-id-2 div.sk-estimator {\n", + " font-family: monospace;\n", + " border: 1px dotted var(--sklearn-color-border-box);\n", + " border-radius: 0.25em;\n", + " box-sizing: border-box;\n", + " margin-bottom: 0.5em;\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-estimator.fitted {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-0);\n", + "}\n", + "\n", + "/* on hover */\n", + "#sk-container-id-2 div.sk-estimator:hover {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-estimator.fitted:hover {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n", + "\n", + "/* Common style for \"i\" and \"?\" */\n", + "\n", + ".sk-estimator-doc-link,\n", + "a:link.sk-estimator-doc-link,\n", + "a:visited.sk-estimator-doc-link {\n", + " float: right;\n", + " font-size: smaller;\n", + " line-height: 1em;\n", + " font-family: monospace;\n", + " background-color: var(--sklearn-color-background);\n", + " border-radius: 1em;\n", + " height: 1em;\n", + " width: 1em;\n", + " text-decoration: none !important;\n", + " margin-left: 1ex;\n", + " /* unfitted */\n", + " border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n", + " color: var(--sklearn-color-unfitted-level-1);\n", + "}\n", + "\n", + ".sk-estimator-doc-link.fitted,\n", + "a:link.sk-estimator-doc-link.fitted,\n", + "a:visited.sk-estimator-doc-link.fitted {\n", + " /* fitted */\n", + " border: var(--sklearn-color-fitted-level-1) 1pt solid;\n", + " color: var(--sklearn-color-fitted-level-1);\n", + "}\n", + "\n", + "/* On hover */\n", + "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n", + ".sk-estimator-doc-link:hover,\n", + "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n", + ".sk-estimator-doc-link:hover {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-3);\n", + " color: var(--sklearn-color-background);\n", + " text-decoration: none;\n", + "}\n", + "\n", + "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n", + ".sk-estimator-doc-link.fitted:hover,\n", + "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n", + ".sk-estimator-doc-link.fitted:hover {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-3);\n", + " color: var(--sklearn-color-background);\n", + " text-decoration: none;\n", + "}\n", + "\n", + "/* Span, style for the box shown on hovering the info icon */\n", + ".sk-estimator-doc-link span {\n", + " display: none;\n", + " z-index: 9999;\n", + " position: relative;\n", + " font-weight: normal;\n", + " right: .2ex;\n", + " padding: .5ex;\n", + " margin: .5ex;\n", + " width: min-content;\n", + " min-width: 20ex;\n", + " max-width: 50ex;\n", + " color: var(--sklearn-color-text);\n", + " box-shadow: 2pt 2pt 4pt #999;\n", + " /* unfitted */\n", + " background: var(--sklearn-color-unfitted-level-0);\n", + " border: .5pt solid var(--sklearn-color-unfitted-level-3);\n", + "}\n", + "\n", + ".sk-estimator-doc-link.fitted span {\n", + " /* fitted */\n", + " background: var(--sklearn-color-fitted-level-0);\n", + " border: var(--sklearn-color-fitted-level-3);\n", + "}\n", + "\n", + ".sk-estimator-doc-link:hover span {\n", + " display: block;\n", + "}\n", + "\n", + "/* \"?\"-specific style due to the `` HTML tag */\n", + "\n", + "#sk-container-id-2 a.estimator_doc_link {\n", + " float: right;\n", + " font-size: 1rem;\n", + " line-height: 1em;\n", + " font-family: monospace;\n", + " background-color: var(--sklearn-color-background);\n", + " border-radius: 1rem;\n", + " height: 1rem;\n", + " width: 1rem;\n", + " text-decoration: none;\n", + " /* unfitted */\n", + " color: var(--sklearn-color-unfitted-level-1);\n", + " border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n", + "}\n", + "\n", + "#sk-container-id-2 a.estimator_doc_link.fitted {\n", + " /* fitted */\n", + " border: var(--sklearn-color-fitted-level-1) 1pt solid;\n", + " color: var(--sklearn-color-fitted-level-1);\n", + "}\n", + "\n", + "/* On hover */\n", + "#sk-container-id-2 a.estimator_doc_link:hover {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-3);\n", + " color: var(--sklearn-color-background);\n", + " text-decoration: none;\n", + "}\n", + "\n", + "#sk-container-id-2 a.estimator_doc_link.fitted:hover {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-3);\n", + "}\n", + "" + ], + "text/plain": [ + "LinearRegression(n_jobs=-1)" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%time adapter.fit(train_x, train_y)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "aa90fa13-efbe-4412-9482-ea692ca10bf6", + "metadata": {}, + "outputs": [], + "source": [ + "pred_y = adapter.predict(test_x)" + ] + }, + { + "cell_type": "markdown", + "id": "1a8b9aa6-418d-4b44-8507-53ffa68cd00b", + "metadata": {}, + "source": [ + "### Check predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "3eefb63f-b411-4cea-85b9-a2f93effa6b0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + "titles = ['Teff', 'log g', '[M/H]']\n", + "\n", + "for i, j in enumerate(titles):\n", + " ax[i].scatter(test_y[:,i], pred_y[:,i], s=5)\n", + " ax[i].plot(test_y[:,i], test_y[:,i], 'r--')\n", + " ax[i].set_title(j)\n", + " ax[i].set_xlabel(\"Truth\")\n", + " ax[i].set_ylabel(\"Predicted\")\n", + " if i == 0:\n", + " ax[i].set_xscale(\"log\")\n", + " ax[i].set_yscale(\"log\")" + ] + }, + { + "cell_type": "markdown", + "id": "0fb7ac6b-7ddf-402f-b4e6-c3ca85b2849a", + "metadata": {}, + "source": [ + "Congrats, you have just done embedding-based adaptation!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mmoma", + "language": "python", + "name": "mmoma" + }, + "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.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}