The Mistral-Maturity-LLM Large Language Model is an improved instruct fine-tuned version of [Mistral-7B-Instruct-v0.1]
					

						
In order to leverage instruction fine-tuning, your prompt should be surrounded by [INST] and [/INST] tokens. The very first instruction should begin with a begin of sentence id. The next instructions should not. The assistant generation will be ended by the end-of-sentence token id.
					
					

						
from transformers import AutoModelForCausalLM, AutoTokenizer

							device = "cuda" # the device to load the model onto
							
							
							messages = [
								{"role": "user", "content": "What is your favourite condiment?"},
								{"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
								{"role": "user", "content": "Do you have mayonnaise recipes?"}
							]
							
							encodeds = tokenizer.apply_chat_template(messages, return_tensors="pt")
							
							model_inputs = encodeds.to(device)
							model.to(device)
							
							generated_ids = model.generate(model_inputs, max_new_tokens=1000, do_sample=True)
							decoded = tokenizer.batch_decode(generated_ids)
							print(decoded[0])
							
					

						
text = "[INST] What is your favourite condiment? [/INST]"
							"Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen! "
							"[INST] Do you have mayonnaise recipes? [/INST]"
							
					

						
from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer
							from peft import LoraConfig
							
							model_id = "facebook/opt-350m"
							model = AutoModelForCausalLM.from_pretrained(model_id)
							
							lora_config = LoraConfig(
								target_modules=["q_proj", "k_proj"],
								init_lora_weights=False
							)
							
							model.add_adapter(lora_config, adapter_name="adapter_1")
					
					

						
+ from accelerate import Accelerator
							from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler
						  
						  + accelerator = Accelerator()
						  
							model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
							optimizer = AdamW(model.parameters(), lr=3e-5)
						  
						  - device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
						  - model.to(device)
						  
						  + train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
						  +     train_dataloader, eval_dataloader, model, optimizer
						  + )
						  
							num_epochs = 3
							num_training_steps = num_epochs * len(train_dataloader)
							lr_scheduler = get_scheduler(
								"linear",
								optimizer=optimizer,
								num_warmup_steps=0,
								num_training_steps=num_training_steps
							)
						  
							progress_bar = tqdm(range(num_training_steps))
						  
							model.train()
							for epoch in range(num_epochs):
								for batch in train_dataloader:
						  -         batch = {k: v.to(device) for k, v in batch.items()}
									outputs = model(**batch)
									loss = outputs.loss
						  -         loss.backward()
						  +         accelerator.backward(loss)
						  
									optimizer.step()
									lr_scheduler.step()
									optimizer.zero_grad()
									progress_bar.update(1)
					

						
This model card corresponds to the 7B base version of the Gemma model. You can also visit the model card of the 2B base model, 7B instruct model, and 2B instruct model.
					

						
Gemma is a family of lightweight, state-of-the-art open models from Google, built from the same research and technology used to create the Gemini models. They are text-to-text, decoder-only large language models, available in English, with open weights, pre-trained variants, and instruction-tuned variants. Gemma models are well-suited for a variety of text generation tasks, including question answering, summarization, and reasoning. Their relatively small size makes it possible to deploy them in environments with limited resources such as a laptop, desktop or your own cloud infrastructure, democratizing access to state of the art AI models and helping foster innovation for everyone.
					

						
Below we share some code snippets on how to get quickly started with running the model. First make sure to pip install -U transformers, then copy the snippet from the section that is relevant for your usecase.
							
							Running the model on a CPU
							from transformers import AutoTokenizer, AutoModelForCausalLM

							tokenizer = AutoTokenizer.from_pretrained("google/gemma-7b")
							model = AutoModelForCausalLM.from_pretrained("google/gemma-7b")

							input_text = "Write me a poem about Machine Learning."
							input_ids = tokenizer(input_text, return_tensors="pt")

							outputs = model.generate(**input_ids)
							print(tokenizer.decode(outputs[0]))

							Running the model on a single / multi GPU
							# pip install accelerate
							from transformers import AutoTokenizer, AutoModelForCausalLM

							tokenizer = AutoTokenizer.from_pretrained("google/gemma-7b")
							model = AutoModelForCausalLM.from_pretrained("google/gemma-7b", device_map="auto")

							input_text = "Write me a poem about Machine Learning."
							input_ids = tokenizer(input_text, return_tensors="pt").to("cuda")

							outputs = model.generate(**input_ids)
							print(tokenizer.decode(outputs[0]))

							Running the model on a GPU using different precisions
							Using torch.float16
							# pip install accelerate
							from transformers import AutoTokenizer, AutoModelForCausalLM

							tokenizer = AutoTokenizer.from_pretrained("google/gemma-7b")
							model = AutoModelForCausalLM.from_pretrained("google/gemma-7b", device_map="auto", torch_dtype=torch.float16)

							input_text = "Write me a poem about Machine Learning."
							input_ids = tokenizer(input_text, return_tensors="pt").to("cuda")

							outputs = model.generate(**input_ids)
							print(tokenizer.decode(outputs[0]))
						
					

						
from transformers import AutoModelForCausalLM, AutoTokenizer
							
							device = "cuda" # the device to load the model onto
			
							model = AutoModelForCausalLM.from_pretrained("prithivMLmods/HealthCare-Instructor-Remedies") tokenizer = AutoTokenizer.from_pretrained("prithivMLmods/HealthCare-Instructor-Remedies")
					

						
Open Health Imaging Foundation [ OHIF ]
							
							Advanced visualization:
							See all the details with support for multi-modal image fusion, multi-planar reformatting, and more

							High-performance:
							Speed up your work with GPU accelerated image rendering and multi-threaded image decoding

							Web application:
							Load cases from anywhere, instantly, with no installation required. Supports all modern browsers.

							User-centered design:
							Professional product and interaction design with a focus on usability


						
					

						
FROM node:18.16.1-slim as json-copier

							RUN mkdir /usr/src/app
							WORKDIR /usr/src/app
							# Clone the application
							RUN apt-get update && apt-get install -y git
							
							RUN git clone --recursive https://github.com/OHIF/Viewers.git .
							
							# # COPY ["package.json", "yarn.lock", "preinstall.js", "./"]
							# COPY extensions /usr/src/app/extensions
							# COPY modes /usr/src/app/modes
							# COPY platform /usr/src/app/platform
							
							# Find and remove non-package.json files
							#RUN find extensions \! -name "package.json" -mindepth 2 -maxdepth 2 -print | xargs rm -rf
							#RUN find modes \! -name "package.json" -mindepth 2 -maxdepth 2 -print | xargs rm -rf
							#RUN find platform \! -name "package.json" -mindepth 2 -maxdepth 2 -print | xargs rm -rf
							
							# Copy Files
							FROM node:18.16.1-slim as builder
							RUN apt-get update && apt-get install -y build-essential python3
							RUN mkdir /usr/src/app
							WORKDIR /usr/src/app
							
							COPY --from=json-copier /usr/src/app .
							
							# Run the install before copying the rest of the files
							RUN yarn config set workspaces-experimental true
							RUN yarn install --frozen-lockfile --verbose
							
							COPY . .
							
							# To restore workspaces symlinks
							RUN yarn install --frozen-lockfile --verbose
							
							ENV PATH /usr/src/app/node_modules/.bin:$PATH
							ENV QUICK_BUILD true
							# ENV GENERATE_SOURCEMAP=false
							# ENV REACT_APP_CONFIG=config/default.js
							
							RUN yarn run build
							# Stage 3: Bundle the built application into a Docker container
							# which runs Nginx using Alpine Linux
							FROM nginxinc/nginx-unprivileged:1.25-alpine as final
							#RUN apk add --no-cache bash
							USER nginx
							COPY --chown=nginx:nginx nginx.conf /etc/nginx/conf.d/default.conf
							COPY --chown=nginx:nginx app-config.js /usr/share/nginx/html/app-config.js
							COPY --from=builder /usr/src/app/platform/app/dist /usr/share/nginx/html
							# In entrypoint.sh, app-config.js might be overwritten, so chmod it to be writeable.
							# The nginx user cannot chmod it, so change to root.
							USER root
							RUN chmod 666 /usr/share/nginx/html/app-config.js
							USER nginx
							CMD ["nginx", "-g", "daemon off;"]
					

						
window.config = {
							routerBasename: "/",
							extensions: [],
							modes: [],
							showStudyList: true,
							dataSources: [
							  { ....
								....
								..
								.
							  }
							
					

						
server {
							listen 7860 default_server;
							listen [::]:7860 default_server;
							location / {
							  root   /usr/share/nginx/html;
							  index  index.html index.htm;
							  try_files $uri $uri/ /index.html;
							  add_header Cross-Origin-Opener-Policy same-origin;
							  add_header Cross-Origin-Embedder-Policy require-corp;
							  add_header Cross-Origin-Resource-Policy cross-origin;
							  proxy_set_header Host $host;
							  proxy_set_header X-Real-IP $remote_addr;
							  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
							  proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
							}
							error_page   500 502 503 504  /50x.html;
							location = /50x.html {
							  root   /usr/share/nginx/html;
							}
						  }
					

						
 title: OHIF
							emoji: 🏃
							colorFrom: pink
							colorTo: yellow
							sdk: docker
							pinned: false
							license: creativeml-openrail-m
					
					

						
Benefit from our thriving open-source community's expertise, collaboration, and innovation for limitless possibilities. Build custom workflows using a composable set of professionally designed React user interface components, leveraging the expertise and contributions of our active community. 
					

						
The Open Medical LLM Leaderboard aims to track, rank and evaluate the performance of large language models (LLMs) on medical question answering tasks. It evaluates LLMs across a diverse array of medical datasets, including MedQA (USMLE), PubMedQA, MedMCQA, and subsets of MMLU related to medicine and biology. The leaderboard offers a comprehensive assessment of each model's medical knowledge and question answering capabilities.
					

						
The clinical database comprises a range of websites crucial for medical practice and study. Among them, one website provides access to heart and breath sounds, aiding in the training and practice of auscultation techniques for medical professionals and students. Additionally, another platform utilizes data from the PTB-XL ECG Database, offering a comprehensive collection of electrocardiogram (ECG) recordings to facilitate the analysis and interpretation of cardiac rhythms for educational and diagnostic purposes. Moreover, leveraging data sourced from the NIH Chest X-ray Database, another website delivers a repository of chest X-ray images, supporting the examination and diagnosis of various pulmonary and thoracic conditions by medical practitioners and learners.
					

						
# Set home to the user's home directory
							ENV HOME=/home/user \
								PATH=/home/user/.local/bin:$PATH 
	
							# Set the working directory to the user's home directory
							WORKDIR $HOME/app
							
							# Copy the current directory contents into the container at $HOME/app setting the owner to the user
							COPY --chown=user . $HOME/app
							
							# Install npm dependencies
							RUN npm install
							
							# Build client and server
							RUN export VITE_SERVER_URL=$MODEL_REPO_NAME && npm run build
							
							EXPOSE 7860
							CMD [ "npm", "run", "start" ]
					

						
 This React component renders a list of medical-related websites with icons, titles, descriptions, and links. It imports necessary modules from React, `react-helmet`, and `react-router-dom`, along with SVG icons for auscultation, ECG, and chest X-ray. 

							The `links` array holds objects with properties for each website, including icon, title, description, and URL. 
							
							Within the `App` component, the `navigate` function is initialized using the `useNavigate` hook.
							
							The component returns JSX, structuring the page with a title, description, and a list of links. It utilizes the `Helmet` component to set the webpage's title. 
							
							The `map` function iterates through the `links` array, rendering each link as a card with its respective icon, title, description, and an "Enter" button. 
							
							Upon clicking the "Enter" button, it navigates to the corresponding link using the `navigate` function, either directly or through React Router routing.
							
							###

							import React from 'react';
							import { Helmet } from 'react-helmet';
							import { useNavigate } from 'react-router-dom';
							import AuscultateSvg from './auscultate.svg';
							import EcgSvg from './ecg.svg';
							import CxrSvg from './xray.svg';
							
							###
							
					

						
 
							This code sets up a React application using React Router for client-side routing. It imports necessary modules from React, including createRoot from react-dom/client, and CSS styles from globals.css. The main component, App, is imported from './App'.

							The code then creates a browser router instance using createBrowserRouter from react-router-dom, specifying a single route for the root path ('/') that renders the App componen
							
							###

							import React from 'react';
							import { createRoot } from 'react-dom/client';
							import './globals.css';
							import App from './App';
							import { createBrowserRouter, RouterProvider } from 'react-router-dom';

							###
						
					

						
app.use((err: unknown, _req: Request, res: Response, next: NextFunction) => {
							if (res.headersSent) {
							  return next(err);

						
});
					
					

						
if (isBoom(err)) {
							return res.status(err.output.statusCode).json(err.output.payload);
						  }
						  next(err);
						});
						
						// Handle client routing, return all requests to the app
						app.get('*', (_req, res) => {
						  res.sendFile(join(__dirname, 'app/index.html'));
						});