Suporte a mais modelos e outros ajustes

server.js

@@ -6,11 +6,236 @@ process.on('uncaughtException', err => console.log('JayCoach:Exception:', err))
 
 const hfToken = process.env.HF_TOKEN
 
+
+const MODELS = {
+	
+	'phi3': {
+		name: 'microsoft/Phi-3-mini-128k-instruct'
+		,prompt: function(prompt){
+			return [
+				"<|user|>"
+				,prompt
+				+"<|end|>"
+				,"<|assistant|>"
+			].join("\n")
+		}
+	}
+	
+	,'phi3mini4': {
+		name: 'microsoft/Phi-3-mini-4k-instruct'
+		,prompt: function(prompt){
+			return [
+				"<|user|>"
+				,prompt
+				+"<|end|>"
+				,"<|assistant|>"
+			].join("\n")
+		}
+	}
+	
+	
+	
+	,'lama': {
+		name: 'meta-llama/Meta-Llama-3-8B-Instruct'
+		,prompt: function(prompt){
+			return [
+				"<|start_header_id|>user<|end_header_id|>"
+				,prompt+"<|eot_id|><|start_header_id|>assistant<|end_header_id|>"
+				+""
+			].join("\n")
+		}
+	}
+	
+	,'mistral':{
+		name: 'mistralai/Mistral-7B-Instruct-v0.3'
+		,prompt: function(prompt){
+			return prompt;
+			return [
+				"[INST]"+prompt+"[/INST]"
+			].join("\n")
+		}
+		
+	}
+	
+}
+
+
 if(!hfToken){
 	throw new Error('NO TOKEN!');
 }
 
-async function Prompt(error, tentativas){
+let LastWorkedModel = '';
+const ModelNames = Object.keys(MODELS);
+const ModelList = []
+let BestModel = {}
+
+for(let modelId in MODELS){
+	let model = MODELS[modelId]
+	
+	model.id 	= modelId
+	model.stats = {
+		 total:0
+		,erros:0
+		,parcela:1
+		,get errop() { return this.total === 0 ? 0 : this.erros/this.total } 
+		,get pok() { return 1 - this.errop } 
+	}
+	
+	ModelList.push(model);
+}
+
+// Encontrar o modelo que oferece que tem melhor chances do acerto!
+/*
+	Se você não entendeu o codigo abaixo, parabens. Eu tb não rsrs.
+	brincadeir... 
+	Aqui é apenas uma pequena maneira de calcular o melhor modelo rpa ser usado...
+	Cada model tem uma prop que chamei de pok (Percentual de OK = % de sucesso quando o model foi usado!)
+	Então, vamos somar todos os percentuais de ok que temos, e atribuir uma parcela desse total pra cada model.
+	O model que tiver mais % de ok dos demais, tem mais chances de ser escolhido do que um que tem menos... 
+	
+	Exemplos:
+	
+	 Phi3  Gemini 			Lama
+	|----|--------|-----------------------------|
+	  10%    20%			 70%
+	   
+	    Phi3  	Gemini 				Lama
+	|--------|----------------|----------------|
+	    20%			 39.9%			40.1%
+	   
+	Agora, escolhe ai um número entre 0 e 100%, aleatoriamente.
+	Se for até 10%, pega  Google... 
+	Se for até entre 10 e 20%, vai o Lama...e acma de 20% vai a Microsoft...
+	
+	Sacou a manha? Com isso, quanto mais um model nao da erro, mais ele tem a chance de ser escolhido!
+	Se 2 models tem o mesmo peso, vamos usar um pequeno hack na conta pra nunca dar empate e um deles sempre ter 1 pouco a mais!
+	   
+	
+	O reusumo é: Imagine aquele meme da Nazaré fazendo as contas!
+*/
+function UpdateProbs(opts){
+	BestModel.LastRandom = Math.random();
+	
+	let AllModels = [];
+	
+	// total de "oks"
+	let Total = ModelList.reduce( (acc,m) => acc + m.stats.pok , 0 )
+	
+	// calcula parcela de ok desse model!
+	ModelList.forEach( m => m.stats.parcela = m.stats.pok/Total  )
+	
+	// Organiza pela ordem...
+	let SortedModels = ModelList.sort( (a,b) => {
+		let diff = a.stats.parcela - b.stats.parcela;
+		
+		if(diff == 0)
+			diff = a.stats.parcela*Math.random() - b.stats.parcela*Math.random()
+		
+		return diff;
+	})
+	
+	BestModel.LastSorted = SortedModels;
+	
+	let parcAcc = 0;
+	for(let [idx,model] of SortedModels.entries()){
+		let stats = model.stats;
+		parcAcc += stats.parcela;
+		
+		if(BestModel.LastRandom <= parcAcc){
+			BestModel.model = model.id;
+			return;
+		}
+	}
+	
+	
+	return;
+}
+
+async function GetModelAnswer(model, prompt){
+	
+	let StartIndex;
+	
+	if(!model){
+		UpdateProbs();
+		model = BestModel.model;
+	}
+
+	
+	let i = ModelList.length;
+	while(i--){ // pra evitar um loop infinito, vai girar no maximo o numero de models...
+		let ModelConfig = MODELS[model];
+		let MyStats = ModelConfig.stats;
+		console.log(MyStats);
+		let InferenceApi = 'https://api-inference.huggingface.co/models/'  + ModelConfig.name;
+		
+		let data ={
+			inputs: ModelConfig.prompt(prompt)
+			,parameters:{
+				 max_new_tokens: 70
+				,return_full_text: false
+				,temperature: 0.5
+			}
+			,options:{
+				use_cache: false
+				,wait_for_model: false
+			}
+		}
+		
+		console.log("Falando com a IA 🤖", model, ModelConfig.name)
+		MyStats.total++
+		const response = await fetch(
+			InferenceApi,
+			{
+				headers: { Authorization: "Bearer "+hfToken, "content-type":"application/json" },
+				method: "POST",
+				body: JSON.stringify(data),
+			}
+		);
+		
+		
+		if(response.status != 200){
+			MyStats.erros++;
+			console.log('FAILED: Escolhendo outro...', response.status)
+			if(StartIndex == null)
+				StartIndex = ModelList.map(m => m.id).indexOf(model);
+			
+			let NextIndex = StartIndex+1;
+			
+			if(NextIndex >= ModelList.length)
+				NextIndex = 0;
+		
+			if(NextIndex == StartIndex){
+				console.log("Fiz de tudo, mas não deu bom :(");
+				throw new Error('SOME_SHIT_HAPPENS');
+			}
+			
+			model = ModelList[NextIndex].id;
+			console.log("Tentando com o ",model);
+			continue;
+		}
+			
+		console.log("Ok, lendo o json...", response.status);
+		const result = await response.json();
+		LastWorkedModel = model;
+		return {
+			result
+			,model
+		}
+	}
+	
+	// se chegou aqui é pq todo mundo falhou!
+	throw new Error('Nenhum model respondeu! O trem tá feio ou o dev cagou em algo...')
+}
+
+async function Prompt(opts){
+	
+	let error 		= opts.error 
+	let tentativas 	= opts.tentativas
+	let max 		= opts.max
+	let model 		= opts.model
+	
+	if(!max)
+		max = 20
 	
 	if(tentativas){
 		tentativas = 'últimas tentativas:'+tentativas
@@ -21,40 +246,40 @@ async function Prompt(error, tentativas){
 	if(error <= 450)
 		tom = `Gere mensagens com bastantes elogios, duvidando se foi realmente um humano que fez isso
 			EXEMPLOS:
-				- Rapaz, acho que isso foi humanamente impossível...
-				- Você não está usando um script não né?
-				- Não é possível, tá muito baixo pra ter sido um ser humano...
+				- Rapaz, acho que isso foi humanamente impossível...|fim|
+				- Você não está usando um script não né?|fim|
+				- Não é possível, tá muito baixo pra ter sido um ser humano...|fim|
 		`
 	else if(error <= 500)
-		tom = `Gere mensagens que parabenizem e elogiem o desempenho
+		tom = `Gere mensagens que parabenizem e elogiem o desempenho.
 			EXEMPLOS:
-				- Muito, muito, mas muito bom!
-				- ora, ora ora, temos um Vingador da IA aqui
-				- Você é o pica das galáxias da IA hein!
+				- Muito, muito, mas muito bom!|fim|
+				- ora, ora ora, temos um Vingador da IA aqui|fim|
+				- Você é o pica das galáxias da IA hein!|fim|
 		`
 	
 	else if(error <= 2000)
 		tom = `Gere mensagens inspiradoras, no sentido em que está indo bem!
 			EXEMPLOS:
-				- Vamos lá, dá pra melhorar, você consegue
-				- Não desista, continue tentando
+				- Vamos lá, dá pra melhorar, você consegue|fim|
+				- Não desista, continue tentando|fim|
 			`
 	else
 		tom = `Gere mensagens sarcástias e engraçadas brincando com a situação. Faça piadas e zoeiras.
 			EXEMPLOS:
-				- Ei, psiu, volta aqui
-				- Ou, não é pra aí não, volta aqui
-				- Você ainda tá tentando ou tá só de brincadeira mesmo?
-				- Ainda bem que eu não sou você hein...
-				- Nossa, mas esse erro tá sensacionalmente errado!
-				- Muito bom continue assim #sqn
+				- Ei, psiu, volta aqui|fim|
+				- Ou, não é pra aí não, volta aqui|fim|
+				- Você ainda tá tentando ou tá só de brincadeira mesmo?|fim|
+				- Ainda bem que eu não sou você hein...|fim|
+				- Nossa, mas esse erro tá sensacionalmente errado!|fim|
+				- Muito bom continue assim #sqn|fim|
 		`
 	
+	let statusErro = "Menor que "
+	
 	let prompt = `
 		Um usuário está estudando Redes Neurais e IA e está aprendendo o conceito de Erro (erro quadrático médio).
-		Ele está fazendo um exercío onde deve conseguir gerar um erro o mais próximo de 0 possível.
-		Gere uma mensagem para ser exibida ao usuário com base no valor do erro atual dele.
-		Use emojis nas respostas, quando apropriado!
+		Ele está fazendo um exercício onde deve conseguir gerar um erro < 499 (menor que 499).
 		
 		${tom}
 		
@@ -62,51 +287,29 @@ async function Prompt(error, tentativas){
 		Informações das tentativas:
 		
 			Erro atual: ${error}
-			${tentativas} 
-		
-		RESTRIÇÕES: máx 20 palavras, encerrar com |fim|
+			${tentativas}
+			Status: ${statusErro}
+			 
+		Gere uma mensagem para ser exibida ao usuário com base no valor do erro e status atual dele.
+		Use emojis nas respostas, quando apropriado!
+		REGRAS: 
+			- máx ${max} palavras
+			- Responda como se estivesse falando diretamente com o usuário (use a segunda pessoa "você").
+			- encerrar com |fim|
+			
+			
 		---
 	`
 	
-	console.log(prompt.length, prompt);
-	
-	let data = {
-		inputs: [
-			"<|user|>"
-			,prompt
-			+"<|end|>"
-			,"<|assistant|>"
-		].join("\n")
-		
-		,parameters:{
-			 max_new_tokens: 70
-			,return_full_text: false
-			,temperature: 0.7
-		}
-		
-		,options:{
-			use_cache: false
-			,wait_for_model: false
-		}
-
-	}
-	
-	const response = await fetch(
-		"https://api-inference.huggingface.co/models/meta-llama/Meta-Llama-3-8B-Instruct",
-		{
-			headers: { Authorization: "Bearer "+hfToken, "content-type":"application/json" },
-			method: "POST",
-			body: JSON.stringify(data),
-		}
-	);
-	
-	const result = await response.json();
-	return result;
+	console.log("PromptLength: ", prompt.length, prompt);
+	let answer = await GetModelAnswer(model, prompt);
+	return answer.result;
 }
 
 app.get('/error', async (req, res) => {
 	
 	let tentativas = req.query.tentativas;
+	let max = 20;
 	
 	if(tentativas && tentativas.length >= 100){
 		res.json({error:"Tentando atacar né?"})
@@ -117,15 +320,32 @@ app.get('/error', async (req, res) => {
 		tentativas = tentativas.split(",").map(Number).join(",");
 	
 	
-	resp = await Prompt(req.query.error, tentativas);
+	resp = await Prompt({
+		 error:req.query.error
+		,tentativas
+		,model:req.query.model
+		,max
+	});
+	
+	console.log("Respondido", resp);
 	
+	if(!resp || !Array.isArray(resp)){
+		res.json({text:":("});
+		return;
+	}
 	
 	let gentext = resp[0].generated_text
 	
 	let textParts = gentext.split('|fim|');
-	let txtFinal = textParts[0];
+	let txtFinal = textParts[0].trim();
+	
+	let estimatedChars = max*8;
+	if(txtFinal.length >= estimatedChars){
+		txtFinal = txtFinal.slice(0,estimatedChars);
+	}
 	
 	console.log("FullResp:"+gentext);
+	console.log("Final:"+txtFinal);
 	res.json({text:txtFinal})
 })
 
@@ -133,6 +353,18 @@ app.get('/test', async (req, res) => {
 	res.send("Working!")
 })
 
+app.get('/models', async (req, res) => {
+	//UpdateProbs()
+	
+	res.json({
+		 BestModel
+	})
+})
+
+app.get('/', async (req, res) => {
+	res.send('JayCoach ON! Veja mais no blog IA Talking: <a href="https://iatalk.ing/tag/jay-trainer">https://iatalk.ing</a>')
+})
+
 app.use(function(err, req, res, next) {
   console.error(err.stack);
   res.json({error:'Server error, admin must check logs',status:res.status})