+
+
diff --git a/config.py b/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..34cfdd7b81ebae22af7bd5008d4b326945addfcc
--- /dev/null
+++ b/config.py
@@ -0,0 +1,4 @@
+RAW_DATASET_ROOT_FOLDER = 'Data'
+
+STATE_DICT_KEY = 'model_state_dict'
+OPTIMIZER_STATE_DICT_KEY = 'optimizer_state_dict'
\ No newline at end of file
diff --git a/favorites-selection.jpg b/favorites-selection.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..eb81d61de59b6964aaf6aa58133b66a68ae1a97d
--- /dev/null
+++ b/favorites-selection.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bffe30762a1ac18edaabc19d89ec987a6e9ad3a83461061c27608eda46e5060
+size 305985
diff --git a/main.py b/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4331c6ca1fba02ee902737ce92fba7ebb23aaf4
--- /dev/null
+++ b/main.py
@@ -0,0 +1,845 @@
+from flask import Flask, render_template, request, jsonify, session, Response
+import sys
+import pickle
+import json
+import gc
+import weakref
+from pathlib import Path
+from utils import *
+from options import args
+from models import model_factory
+from flask_socketio import SocketIO, emit
+from datetime import datetime
+import random
+import re
+import xml.etree.ElementTree as ET
+
+app = Flask(__name__)
+app.secret_key = '1903bjk'
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+# Memory-efficient chat system
+class ChatManager:
+ def __init__(self, max_messages=100): # Reduced from 300
+ self.messages = []
+ self.active_users = {}
+ self.max_messages = max_messages
+
+ def add_message(self, message):
+ self.messages.append(message)
+ if len(self.messages) > self.max_messages:
+ self.messages.pop(0)
+
+ def get_messages(self):
+ return self.messages
+
+ def add_user(self, sid, username):
+ self.active_users[sid] = {
+ 'username': username,
+ 'connected_at': datetime.now()
+ }
+
+ def remove_user(self, sid):
+ return self.active_users.pop(sid, None)
+
+ def get_user_count(self):
+ return len(self.active_users)
+
+ def get_username(self, sid):
+ user = self.active_users.get(sid)
+ return user['username'] if user else None
+
+ def update_username(self, sid, new_username):
+ if sid in self.active_users:
+ self.active_users[sid]['username'] = new_username
+
+chat_manager = ChatManager()
+
+def generate_username():
+ adjectives = ['Cool', 'Awesome', 'Swift', 'Bright', 'Happy', 'Smart', 'Kind', 'Brave', 'Calm', 'Epic', "Black"]
+ nouns = ['Otaku', 'Ninja', 'Samurai', 'Dragon', 'Phoenix', 'Tiger', 'Wolf', 'Eagle', 'Fox', 'Bear']
+ return f"{random.choice(adjectives)}{random.choice(nouns)}{random.randint(100, 999)}"
+
+def clean_message(message):
+ # HTML tag'leri temizle
+ message = re.sub(r'<[^>]*>', '', message)
+ # Uzunluk kontrolü
+ if len(message) > 500:
+ message = message[:500]
+ return message.strip()
+
+# Lazy loading için wrapper class
+class LazyDict:
+ def __init__(self, file_path):
+ self.file_path = file_path
+ self._data = None
+ self._loaded = False
+
+ def _load_data(self):
+ if not self._loaded:
+ try:
+ with open(self.file_path, "r", encoding="utf-8") as file:
+ self._data = json.load(file)
+ self._loaded = True
+ except Exception as e:
+ print(f"Warning: Could not load {self.file_path}: {str(e)}")
+ self._data = {}
+ self._loaded = True
+
+ def get(self, key, default=None):
+ self._load_data()
+ return self._data.get(key, default)
+
+ def __contains__(self, key):
+ self._load_data()
+ return key in self._data
+
+ def items(self):
+ self._load_data()
+ return self._data.items()
+
+ def keys(self):
+ self._load_data()
+ return self._data.keys()
+
+ def __len__(self):
+ self._load_data()
+ return len(self._data)
+
+# Sitemap route'ları
+@app.route('/sitemap.xml')
+def sitemap():
+ """Dinamik sitemap.xml oluşturur"""
+ try:
+ # XML root element
+ urlset = ET.Element('urlset')
+ urlset.set('xmlns', 'http://www.sitemaps.org/schemas/sitemap/0.9')
+ urlset.set('xmlns:image', 'http://www.google.com/schemas/sitemap-image/1.1')
+
+ # Base URL
+ base_url = request.url_root.rstrip('/')
+ current_date = datetime.now().strftime('%Y-%m-%d')
+
+ # Ana sayfa
+ url = ET.SubElement(urlset, 'url')
+ ET.SubElement(url, 'loc').text = f'{base_url}/'
+ ET.SubElement(url, 'lastmod').text = current_date
+ ET.SubElement(url, 'changefreq').text = 'daily'
+ ET.SubElement(url, 'priority').text = '1.0'
+
+ # Chat sayfası
+ url = ET.SubElement(urlset, 'url')
+ ET.SubElement(url, 'loc').text = f'{base_url}/chat'
+ ET.SubElement(url, 'lastmod').text = current_date
+ ET.SubElement(url, 'changefreq').text = 'hourly'
+ ET.SubElement(url, 'priority').text = '0.8'
+
+ # Anime sayfaları (sadece ilk 50 anime - SEO için)
+ if recommendation_system and recommendation_system.id_to_anime:
+ anime_count = 0
+ for anime_id, anime_data in recommendation_system.id_to_anime.items():
+ if anime_count >= 50: # Reduced from 100
+ break
+
+ try:
+ anime_name = anime_data[0] if isinstance(anime_data, list) and len(anime_data) > 0 else str(anime_data)
+ safe_name = anime_name.replace(' ', '-').replace('/', '-').replace('?', '').replace('&', 'and')
+ safe_name = re.sub(r'[^\w\-]', '', safe_name)
+
+ url = ET.SubElement(urlset, 'url')
+ ET.SubElement(url, 'loc').text = f'{base_url}/anime/{anime_id}/{safe_name}'
+ ET.SubElement(url, 'lastmod').text = current_date
+ ET.SubElement(url, 'changefreq').text = 'weekly'
+ ET.SubElement(url, 'priority').text = '0.6'
+
+ # Sadece gerekli durumlarda resim URL'si ekle
+ if anime_count < 20: # Sadece ilk 20 anime için resim
+ image_url = recommendation_system.get_anime_image_url(int(anime_id))
+ if image_url:
+ image_elem = ET.SubElement(url, 'image:image')
+ ET.SubElement(image_elem, 'image:loc').text = image_url
+ ET.SubElement(image_elem, 'image:title').text = anime_name
+ ET.SubElement(image_elem, 'image:caption').text = f'Poster image for {anime_name}'
+
+ anime_count += 1
+ except Exception as e:
+ print(f"Error processing anime {anime_id}: {e}")
+ continue
+
+ # XML'i string'e çevir
+ xml_str = ET.tostring(urlset, encoding='unicode')
+ xml_declaration = '\n'
+ full_xml = xml_declaration + xml_str
+
+ return Response(full_xml, mimetype='application/xml')
+
+ except Exception as e:
+ print(f"Sitemap generation error: {e}")
+ return Response(
+ '
+
+
+
diff --git a/templates/chat.html b/templates/chat.html
new file mode 100644
index 0000000000000000000000000000000000000000..25a424d79f605280fe645e1a5e495340310c02e4
--- /dev/null
+++ b/templates/chat.html
@@ -0,0 +1,459 @@
+
+
+
+
+
+
+
+
+
+
+ {% if anime.image_url %}
+ 
+ {% else %}
+
+
+
+ No Image Available
+
+ {% endif %}
+
+
+ {{ anime.name }}
+ + {% if anime.genres %} +
+ Genres:
+ {% for genre in anime.genres %}
+ {{ genre }}
+ {% endfor %}
+
+ {% endif %}
+
+ {% if anime.mal_url %}
+
+ View on MyAnimeList
+
+ {% endif %}
+
+
+
+
+ {% if anime.similar_animes %}
+ Summary
+
+
+ Summary will be added here in the future.
+
+
+
+ {% endif %}
+ Similar Animes
+
+ {% for similar in anime.similar_animes %}
+
+
+ {% if similar.image_url %}
+ 
+ {% else %}
+
+ {% endfor %}
+
+ No Image
+
+ {% endif %}
+
+
+ {{ similar.name }}
+ {% if similar.genres %}
+
+ {{ similar.genres[:3] | join(', ') }}
+
+ {% endif %}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/templates/error.html b/templates/error.html
new file mode 100644
index 0000000000000000000000000000000000000000..1c0de8e72e3eb0ac78e582a6f47a87ec84b15d89
--- /dev/null
+++ b/templates/error.html
@@ -0,0 +1,291 @@
+
+
+
+
+
+
+
+
+
+
+
+ 💬
+ Anime Chat
+
+
+ Online: 0
+
+
+
+
+
+
+
+
+
+
+
+ ⚡
+ 🌟
+ 🎌
+ 🗾
+
+
+
+
+
+
+
+
+
diff --git a/templates/index.html b/templates/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..b551c703efef2b37212bbef5bf9f0f41f4c0e520
--- /dev/null
+++ b/templates/index.html
@@ -0,0 +1,1130 @@
+
+
+
+
+
+ Oops! Something went wrong
+ + + + {% if error %} +
+ Error Details:
+ {{ error }} +
+ {% endif %}
+
+
+
+ + {{ error }} +
+
+ 🔧 Troubleshooting Tips:
+-
+
- Check if the server is running properly +
- Verify your internet connection +
- Try refreshing the page +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/templates/loading.html b/templates/loading.html
new file mode 100644
index 0000000000000000000000000000000000000000..79c1c14d41e3ac717b3fbe3065b1862e2ac54835
--- /dev/null
+++ b/templates/loading.html
@@ -0,0 +1,168 @@
+
+
+
+
+
+
+
+
+
+ Just one episode...
+Discover your next favorite anime
+
+
+
+
+
+ Select Your Favorite Animes
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Blacklisted Animes
+ +
+
+
+
+
+
+
+ No favorites selected yet. Search and add some animes!
+
+
+
+
+
+ Recommended for You
+
+
+
+
+
+
+
+
+
+
+
+
+ About the Model
+Despite its strong performance, I couldn't find any anime recommendation websites using a BERT-based recommender system. This recommendation system uses a BERT transformer specifically for anime recommendations. Unlike other systems, it takes only users' favorite anime titles as input, rather than ratings. I believe the BERT model handled the recommendation task very well, including effectively addressing the cold start problem by generating meaningful recommendations even with limited user data.
+
+
+
+ Purpose
+AnimeRecbert was built with the mission of making anime discovery smarter, more personal, and more enjoyable. Instead of relying on generic ratings or tags, it uses the power of modern NLP — specifically BERT — to understand your favorite titles and suggest anime that match your unique preferences. Our goal is to reimagine recommendation systems by combining deep language understanding with intuitive user interaction. Whether you're a seasoned anime fan or just getting started, AnimeRecbert helps you find your next favorite show effortlessly.
+
+
+
+ Contact & Feedback
+ +
+
+ GitHub Repo
+ +
+
+
+
+
+
diff --git a/utils.py b/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ca38052cbeada75dd1adff6c8bf3d4c2dd23844
--- /dev/null
+++ b/utils.py
@@ -0,0 +1,153 @@
+from config import *
+
+import json
+import os
+import pprint as pp
+import random
+from datetime import date
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.backends.cudnn as cudnn
+from torch import optim as optim
+
+
+def setup_train(args):
+ set_up_gpu(args)
+
+ export_root = create_experiment_export_folder(args)
+ export_experiments_config_as_json(args, export_root)
+
+ pp.pprint({k: v for k, v in vars(args).items() if v is not None}, width=1)
+ return export_root
+
+
+def create_experiment_export_folder(args):
+ experiment_dir, experiment_description = args.experiment_dir, args.experiment_description
+ if not os.path.exists(experiment_dir):
+ os.mkdir(experiment_dir)
+ experiment_path = get_name_of_experiment_path(experiment_dir, experiment_description)
+ os.mkdir(experiment_path)
+ print('Folder created: ' + os.path.abspath(experiment_path))
+ return experiment_path
+
+
+def get_name_of_experiment_path(experiment_dir, experiment_description):
+ experiment_path = os.path.join(experiment_dir, (experiment_description + "_" + str(date.today())))
+ idx = _get_experiment_index(experiment_path)
+ experiment_path = experiment_path + "_" + str(idx)
+ return experiment_path
+
+
+def _get_experiment_index(experiment_path):
+ idx = 0
+ while os.path.exists(experiment_path + "_" + str(idx)):
+ idx += 1
+ return idx
+
+
+def load_weights(model, path):
+ pass
+
+
+def save_test_result(export_root, result):
+ filepath = Path(export_root).joinpath('test_result.txt')
+ with filepath.open('w') as f:
+ json.dump(result, f, indent=2)
+
+
+def export_experiments_config_as_json(args, experiment_path):
+ with open(os.path.join(experiment_path, 'config.json'), 'w') as outfile:
+ json.dump(vars(args), outfile, indent=2)
+
+
+def fix_random_seed_as(random_seed):
+ random.seed(random_seed)
+ torch.manual_seed(random_seed)
+ torch.cuda.manual_seed_all(random_seed)
+ np.random.seed(random_seed)
+ cudnn.deterministic = True
+ cudnn.benchmark = False
+
+
+def set_up_gpu(args):
+ os.environ['CUDA_VISIBLE_DEVICES'] = args.device_idx
+ args.num_gpu = len(args.device_idx.split(","))
+
+
+def load_pretrained_weights(model, path):
+ chk_dict = torch.load(os.path.abspath(path))
+ model_state_dict = chk_dict[STATE_DICT_KEY] if STATE_DICT_KEY in chk_dict else chk_dict['state_dict']
+ model.load_state_dict(model_state_dict)
+
+
+def setup_to_resume(args, model, optimizer):
+ chk_dict = torch.load(os.path.join(os.path.abspath(args.resume_training), 'models/checkpoint-recent.pth'))
+ model.load_state_dict(chk_dict[STATE_DICT_KEY])
+ optimizer.load_state_dict(chk_dict[OPTIMIZER_STATE_DICT_KEY])
+
+
+def create_optimizer(model, args):
+ if args.optimizer == 'Adam':
+ return optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)
+
+ return optim.SGD(model.parameters(), lr=args.lr, weight_decay=args.weight_decay, momentum=args.momentum)
+
+
+class AverageMeterSet(object):
+ def __init__(self, meters=None):
+ self.meters = meters if meters else {}
+
+ def __getitem__(self, key):
+ if key not in self.meters:
+ meter = AverageMeter()
+ meter.update(0)
+ return meter
+ return self.meters[key]
+
+ def update(self, name, value, n=1):
+ if name not in self.meters:
+ self.meters[name] = AverageMeter()
+ self.meters[name].update(value, n)
+
+ def reset(self):
+ for meter in self.meters.values():
+ meter.reset()
+
+ def values(self, format_string='{}'):
+ return {format_string.format(name): meter.val for name, meter in self.meters.items()}
+
+ def averages(self, format_string='{}'):
+ return {format_string.format(name): meter.avg for name, meter in self.meters.items()}
+
+ def sums(self, format_string='{}'):
+ return {format_string.format(name): meter.sum for name, meter in self.meters.items()}
+
+ def counts(self, format_string='{}'):
+ return {format_string.format(name): meter.count for name, meter in self.meters.items()}
+
+
+class AverageMeter(object):
+ """Computes and stores the average and current value"""
+
+ def __init__(self):
+ self.val = 0
+ self.avg = 0
+ self.sum = 0
+ self.count = 0
+
+ def reset(self):
+ self.val = 0
+ self.avg = 0
+ self.sum = 0
+ self.count = 0
+
+ def update(self, val, n=1):
+ self.val = val
+ self.sum += val
+ self.count += n
+ self.avg = self.sum / self.count
+
+ def __format__(self, format):
+ return "{self.val:{format}} ({self.avg:{format}})".format(self=self, format=format)
🎌 Anime Recommendation System
+ + +Loading AI model and anime database...
+This may take a few minutes on first load
+ +