update

README.md

@@ -1,5 +1,5 @@
 ---
-title: 'FineVision: Open Data is all you need'
+title: 'Bringing paper to life: A modern template for scientific writing'
 emoji: 📝
 colorFrom: blue
 colorTo: indigo

app/.astro/astro/content.d.ts

@@ -0,0 +1,217 @@
+declare module 'astro:content' {
+	interface Render {
+		'.mdx': Promise<{
+			Content: import('astro').MarkdownInstance<{}>['Content'];
+			headings: import('astro').MarkdownHeading[];
+			remarkPluginFrontmatter: Record<string, any>;
+			components: import('astro').MDXInstance<{}>['components'];
+		}>;
+	}
+}
+
+declare module 'astro:content' {
+	interface RenderResult {
+		Content: import('astro/runtime/server/index.js').AstroComponentFactory;
+		headings: import('astro').MarkdownHeading[];
+		remarkPluginFrontmatter: Record<string, any>;
+	}
+	interface Render {
+		'.md': Promise<RenderResult>;
+	}
+
+	export interface RenderedContent {
+		html: string;
+		metadata?: {
+			imagePaths: Array<string>;
+			[key: string]: unknown;
+		};
+	}
+}
+
+declare module 'astro:content' {
+	type Flatten<T> = T extends { [K: string]: infer U } ? U : never;
+
+	export type CollectionKey = keyof AnyEntryMap;
+	export type CollectionEntry<C extends CollectionKey> = Flatten<AnyEntryMap[C]>;
+
+	export type ContentCollectionKey = keyof ContentEntryMap;
+	export type DataCollectionKey = keyof DataEntryMap;
+
+	type AllValuesOf<T> = T extends any ? T[keyof T] : never;
+	type ValidContentEntrySlug<C extends keyof ContentEntryMap> = AllValuesOf<
+		ContentEntryMap[C]
+	>['slug'];
+
+	/** @deprecated Use `getEntry` instead. */
+	export function getEntryBySlug<
+		C extends keyof ContentEntryMap,
+		E extends ValidContentEntrySlug<C> | (string & {}),
+	>(
+		collection: C,
+		// Note that this has to accept a regular string too, for SSR
+		entrySlug: E,
+	): E extends ValidContentEntrySlug<C>
+		? Promise<CollectionEntry<C>>
+		: Promise<CollectionEntry<C> | undefined>;
+
+	/** @deprecated Use `getEntry` instead. */
+	export function getDataEntryById<C extends keyof DataEntryMap, E extends keyof DataEntryMap[C]>(
+		collection: C,
+		entryId: E,
+	): Promise<CollectionEntry<C>>;
+
+	export function getCollection<C extends keyof AnyEntryMap, E extends CollectionEntry<C>>(
+		collection: C,
+		filter?: (entry: CollectionEntry<C>) => entry is E,
+	): Promise<E[]>;
+	export function getCollection<C extends keyof AnyEntryMap>(
+		collection: C,
+		filter?: (entry: CollectionEntry<C>) => unknown,
+	): Promise<CollectionEntry<C>[]>;
+
+	export function getEntry<
+		C extends keyof ContentEntryMap,
+		E extends ValidContentEntrySlug<C> | (string & {}),
+	>(entry: {
+		collection: C;
+		slug: E;
+	}): E extends ValidContentEntrySlug<C>
+		? Promise<CollectionEntry<C>>
+		: Promise<CollectionEntry<C> | undefined>;
+	export function getEntry<
+		C extends keyof DataEntryMap,
+		E extends keyof DataEntryMap[C] | (string & {}),
+	>(entry: {
+		collection: C;
+		id: E;
+	}): E extends keyof DataEntryMap[C]
+		? Promise<DataEntryMap[C][E]>
+		: Promise<CollectionEntry<C> | undefined>;
+	export function getEntry<
+		C extends keyof ContentEntryMap,
+		E extends ValidContentEntrySlug<C> | (string & {}),
+	>(
+		collection: C,
+		slug: E,
+	): E extends ValidContentEntrySlug<C>
+		? Promise<CollectionEntry<C>>
+		: Promise<CollectionEntry<C> | undefined>;
+	export function getEntry<
+		C extends keyof DataEntryMap,
+		E extends keyof DataEntryMap[C] | (string & {}),
+	>(
+		collection: C,
+		id: E,
+	): E extends keyof DataEntryMap[C]
+		? Promise<DataEntryMap[C][E]>
+		: Promise<CollectionEntry<C> | undefined>;
+
+	/** Resolve an array of entry references from the same collection */
+	export function getEntries<C extends keyof ContentEntryMap>(
+		entries: {
+			collection: C;
+			slug: ValidContentEntrySlug<C>;
+		}[],
+	): Promise<CollectionEntry<C>[]>;
+	export function getEntries<C extends keyof DataEntryMap>(
+		entries: {
+			collection: C;
+			id: keyof DataEntryMap[C];
+		}[],
+	): Promise<CollectionEntry<C>[]>;
+
+	export function render<C extends keyof AnyEntryMap>(
+		entry: AnyEntryMap[C][string],
+	): Promise<RenderResult>;
+
+	export function reference<C extends keyof AnyEntryMap>(
+		collection: C,
+	): import('astro/zod').ZodEffects<
+		import('astro/zod').ZodString,
+		C extends keyof ContentEntryMap
+			? {
+					collection: C;
+					slug: ValidContentEntrySlug<C>;
+				}
+			: {
+					collection: C;
+					id: keyof DataEntryMap[C];
+				}
+	>;
+	// Allow generic `string` to avoid excessive type errors in the config
+	// if `dev` is not running to update as you edit.
+	// Invalid collection names will be caught at build time.
+	export function reference<C extends string>(
+		collection: C,
+	): import('astro/zod').ZodEffects<import('astro/zod').ZodString, never>;
+
+	type ReturnTypeOrOriginal<T> = T extends (...args: any[]) => infer R ? R : T;
+	type InferEntrySchema<C extends keyof AnyEntryMap> = import('astro/zod').infer<
+		ReturnTypeOrOriginal<Required<ContentConfig['collections'][C]>['schema']>
+	>;
+
+	type ContentEntryMap = {
+		"chapters": {
+"available-blocks.mdx": {
+	id: "available-blocks.mdx";
+  slug: "available-blocks";
+  body: string;
+  collection: "chapters";
+  data: any
+} & { render(): Render[".mdx"] };
+"best-pratices.mdx": {
+	id: "best-pratices.mdx";
+  slug: "best-pratices";
+  body: string;
+  collection: "chapters";
+  data: any
+} & { render(): Render[".mdx"] };
+"getting-started.mdx": {
+	id: "getting-started.mdx";
+  slug: "getting-started";
+  body: string;
+  collection: "chapters";
+  data: any
+} & { render(): Render[".mdx"] };
+"introduction.mdx": {
+	id: "introduction.mdx";
+  slug: "introduction";
+  body: string;
+  collection: "chapters";
+  data: any
+} & { render(): Render[".mdx"] };
+"writing-your-content.mdx": {
+	id: "writing-your-content.mdx";
+  slug: "writing-your-content";
+  body: string;
+  collection: "chapters";
+  data: any
+} & { render(): Render[".mdx"] };
+};
+"embeds": {
+"vibe-code-d3-embeds-directives.md": {
+	id: "vibe-code-d3-embeds-directives.md";
+  slug: "vibe-code-d3-embeds-directives";
+  body: string;
+  collection: "embeds";
+  data: any
+} & { render(): Render[".md"] };
+};
+
+	};
+
+	type DataEntryMap = {
+		"assets": {
+"data/mnist-variant-model": {
+	id: "data/mnist-variant-model";
+  collection: "assets";
+  data: any
+};
+};
+
+	};
+
+	type AnyEntryMap = ContentEntryMap & DataEntryMap;
+
+	export type ContentConfig = never;
+}

app/src/content/bibliography.bib

@@ -18,3 +18,125 @@
 }
 
 
+@book{mckinney2017python,
+  title={Python for Data Analysis},
+  author={McKinney, Wes},
+  publisher={O'Reilly Media},
+  address={Sebastopol, CA},
+  year={2017},
+  edition={2},
+  isbn={978-1491957660}
+}
+
+@inproceedings{he2016resnet,
+  title={Deep Residual Learning for Image Recognition},
+  author={He, Kaiming and Zhang, Xiangyu and Ren, Shaoqing and Sun, Jian},
+  booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
+  pages={770--778},
+  year={2016},
+  doi={10.1109/CVPR.2016.90},
+  url={https://doi.org/10.1109/CVPR.2016.90}
+}
+
+@article{silver2017mastering,
+  title={Mastering the game of Go without human knowledge},
+  author={Silver, David and Schrittwieser, Julian and Simonyan, Karen and Antonoglou, Ioannis and Huang, Aja and others},
+  journal={Nature},
+  volume={550},
+  number={7676},
+  pages={354--359},
+  year={2017},
+  month={oct},
+  doi={10.1038/nature24270},
+  url={https://www.nature.com/articles/nature24270}
+}
+
+@techreport{openai2023gpt4,
+  title={GPT-4 Technical Report},
+  author={{OpenAI}},
+  institution={OpenAI},
+  year={2023},
+  number={arXiv:2303.08774},
+  archivePrefix={arXiv},
+  eprint={2303.08774},
+  primaryClass={cs.CL},
+  url={https://arxiv.org/abs/2303.08774}
+}
+
+@phdthesis{doe2020thesis,
+  title={Learning Efficient Representations for Large-Scale Visual Recognition},
+  author={Doe, Jane},
+  school={Massachusetts Institute of Technology},
+  address={Cambridge, MA},
+  year={2020},
+  doi={10.5555/mit-2020-xyz}
+}
+
+@incollection{cover2006entropy,
+  title={Entropy, Relative Entropy, and Mutual Information},
+  author={Cover, Thomas M. and Thomas, Joy A.},
+  booktitle={Elements of Information Theory},
+  publisher={Wiley},
+  address={Hoboken, NJ},
+  edition={2},
+  year={2006},
+  pages={13--55},
+  isbn={978-0471241959}
+}
+
+@misc{zenodo2021dataset,
+  title={ImageNet-21K Subset (Version 2.0)},
+  author={Smith, John and Lee, Alice and Kumar, Ravi},
+  year={2021},
+  howpublished={Dataset on Zenodo},
+  doi={10.5281/zenodo.1234567},
+  url={https://doi.org/10.5281/zenodo.1234567},
+  note={Accessed 2025-09-01}
+}
+
+@misc{sklearn2024,
+  title={scikit-learn: Machine Learning in Python (Version 1.4)},
+  author={Pedregosa, Fabian and Varoquaux, Ga{"e}l and Gramfort, Alexandre and others},
+  year={2024},
+  howpublished={Software},
+  doi={10.5281/zenodo.592264},
+  url={https://scikit-learn.org}
+}
+
+@inproceedings{smith2024privacy,
+  title={Privacy-Preserving Training with Low-Precision Secure Aggregation},
+  author={Smith, Emily and Zhang, Wei and Rossi, Marco and Patel, Neha},
+  booktitle={Proceedings of the 41st International Conference on Machine Learning},
+  editor={Smith, A. and Johnson, B.},
+  series={Proceedings of Machine Learning Research},
+  volume={235},
+  pages={12345--12367},
+  address={Vienna, Austria},
+  publisher={PMLR},
+  month={jul},
+  year={2024},
+  url={https://proceedings.mlr.press/v235/}
+}
+
+@article{kingma2015adam,
+  title={Adam: A Method for Stochastic Optimization},
+  author={Kingma, Diederik P. and Ba, Jimmy},
+  journal={International Conference on Learning Representations (ICLR)},
+  year={2015},
+  archivePrefix={arXiv},
+  eprint={1412.6980},
+  primaryClass={cs.LG},
+  url={https://arxiv.org/abs/1412.6980}
+}
+
+@misc{raffel2020t5,
+  title={Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer},
+  author={Raffel, Colin and Shazeer, Noam and Roberts, Adam and Lee, Katherine and Narang, Sharan and others},
+  year={2020},
+  howpublished={arXiv preprint},
+  archivePrefix={arXiv},
+  eprint={1910.10683},
+  primaryClass={cs.LG},
+  doi={10.48550/arXiv.1910.10683},
+  url={https://arxiv.org/abs/1910.10683}
+}