featrixsphere 0.1.57__py3-none-any.whl → 0.2.1233__py3-none-any.whl

featrixsphere/__init__.py

@@ -7,6 +7,8 @@ The Featrix Sphere API automatically builds neural embedding spaces from your da
 and trains high-accuracy predictors without requiring any ML expertise. 
 Just upload your data, specify what you want to predict, and get a production API endpoint.
 
+NEW: Beautiful training visualization with matplotlib plotting!
+
 Example:
     >>> from featrixsphere import FeatrixSphereClient
     >>> import pandas as pd
@@ -20,23 +22,33 @@ Example:
     >>> # Or upload CSV file directly (with automatic gzip compression)
     >>> session = client.upload_df_and_create_session(file_path="data.csv")
     >>> 
-    >>> # Or use the original file upload method
-    >>> session = client.upload_file_and_create_session("data.csv")
-    >>> 
+    >>> # Train a predictor
     >>> client.train_single_predictor(session.session_id, "target_column", "set")
+    >>> 
+    >>> # Make predictions
     >>> result = client.predict(session.session_id, {"feature": "value"})
     >>> print(result['prediction'])
+    >>> 
+    >>> # NEW: Visualize training progress with beautiful plots!
+    >>> fig = client.plot_training_loss(session.session_id, style='notebook')
+    >>> # Returns matplotlib Figure - perfect for Jupyter notebooks!
+    >>> 
+    >>> # Compare multiple training runs
+    >>> client.plot_training_comparison(['session1', 'session2'], 
+    ...                                labels=['Experiment A', 'Experiment B'])
 """
 
-__version__ = "0.1.57"
+__version__ = "0.2.1233"
 __author__ = "Featrix"
 __email__ = "support@featrix.com"
 __license__ = "MIT"
 
-from .client import FeatrixSphereClient, SessionInfo
+from .client import FeatrixSphereClient, SessionInfo, PredictionBatch, PredictionGrid
 
 __all__ = [
     "FeatrixSphereClient",
-    "SessionInfo",
+    "SessionInfo", 
+    "PredictionBatch",
+    "PredictionGrid",
     "__version__",
 ] 

featrixsphere/cli.py

@@ -19,18 +19,23 @@ def main():
         epilog="""
 Examples:
   # Upload data and create session
-  featrix upload data.csv --server http://localhost:8000
+  featrix upload data.csv --server YOUR_SERVER_URL
   
   # Test predictions on CSV
-  featrix test SESSION_ID test.csv target_column --server http://localhost:8000
+  featrix test SESSION_ID test.csv target_column --server YOUR_SERVER_URL
   
-  # Make single prediction
-  featrix predict SESSION_ID '{"feature": "value"}' --server http://localhost:8000
+  # Make single prediction from JSON
+  featrix predict SESSION_ID '{"feature": "value"}' --server YOUR_SERVER_URL
+  
+  # Make predictions from CSV file
+  featrix predict SESSION_ID test.csv --server YOUR_SERVER_URL --sample-size 50
         """
     )
     
-    parser.add_argument("--server", default="http://localhost:8000", 
+    parser.add_argument("--server", default="https://sphere-api.featrix.com",
                        help="Featrix Sphere server URL")
+    parser.add_argument("--compute-cluster", type=str, default=None,
+                       help="Compute cluster port for X-Sphere-Compute header")
     parser.add_argument("--version", action="version", 
                        version=f"featrixsphere {__import__('featrixsphere').__version__}")
     
@@ -53,7 +58,11 @@ Examples:
     # Predict command
     predict_parser = subparsers.add_parser("predict", help="Make single prediction")
     predict_parser.add_argument("session_id", help="Session ID")
-    predict_parser.add_argument("record", help="JSON record to predict")
+    predict_parser.add_argument("input", help="JSON record or CSV file to predict")
+    predict_parser.add_argument("--sample-size", type=int, default=1000,
+                               help="Number of records to predict from CSV (default: 1000)")
+    predict_parser.add_argument("-v", "--verbose", action="store_true",
+                               help="Print full results structure")
     
     # Status command
     status_parser = subparsers.add_parser("status", help="Check session status")
@@ -66,7 +75,7 @@ Examples:
         return 1
     
     try:
-        client = FeatrixSphereClient(args.server)
+        client = FeatrixSphereClient(args.server, compute_cluster=args.compute_cluster)
         
         if args.command == "upload":
             return cmd_upload(client, args)
@@ -137,28 +146,144 @@ def cmd_test(client, args):
 def cmd_predict(client, args):
     """Handle predict command."""
     import json
+    import pandas as pd
+    from pathlib import Path
+    
+    input_path = Path(args.input)
     
+    # Check if input is a CSV file
+    if input_path.exists() and input_path.suffix.lower() == '.csv':
+        print(f"📊 Loading CSV file: {input_path}")
+        try:
+            df = pd.read_csv(input_path)
+            print(f"   Loaded {len(df)} records")
+            
+            # Sample records if requested (default is 1000, so only sample if explicitly set lower)
+            if args.sample_size < len(df):
+                df = df.sample(n=args.sample_size, random_state=42)
+                print(f"   Sampling {len(df)} records for prediction")
+            
+            # Remove target column to avoid warnings
+            target_column = 'Cancellation Non Renewal'
+            if target_column in df.columns:
+                df = df.drop(columns=[target_column])
+                print(f"   Removed target column '{target_column}' from prediction data")
+            
+            print(f"\n🎯 Making predictions for {len(df)} records...")
+            
+            # Make individual predictions (simpler and more reliable)
+            results = []
+            for i, (_, row) in enumerate(df.iterrows()):
+                record = row.to_dict()
+                print(f"   Predicting record {i+1}/{len(df)}...", end=" ")
+                
+                try:
+                    result = client.predict(args.session_id, record)
+                    
+                    # Extract prediction from response
+                    if 'results' in result:
+                        prediction = result['results']
+                        # Get top prediction
+                        predicted_class = max(prediction, key=prediction.get)
+                        confidence = prediction[predicted_class]
+                    elif 'metadata' in result:
+                        # Use metadata if available (server already computed highest probability)
+                        predicted_class = result['metadata'].get('predicted_class', 'Unknown')
+                        confidence = result['metadata'].get('confidence', 0.0)
+                        prediction = {predicted_class: confidence}
+                    else:
+                        raise ValueError("No prediction results found in response")
+                    
+                    results.append({
+                        'record': i+1,
+                        'prediction': predicted_class,
+                        'confidence': confidence*100
+                    })
+                    
+                    if args.verbose:
+                        print(f"→ {predicted_class} ({confidence*100:.6f}%)")
+                        print(f"   Full results: {prediction}")
+                    else:
+                        print(f"→ {predicted_class} ({confidence*100:.6f}%)")
+                    
+                except Exception as e:
+                    print(f"❌ Error: {e}")
+                    results.append({
+                        'record': i+1,
+                        'prediction': 'ERROR',
+                        'confidence': 0
+                    })
+            
+            # Summary
+            print(f"\n📈 Prediction Summary:")
+            successful = [r for r in results if r['prediction'] != 'ERROR']
+            if successful:
+                avg_confidence = sum(r['confidence'] for r in successful) / len(successful)
+                print(f"   ✅ {len(successful)}/{len(results)} successful predictions")
+                print(f"   📊 Average confidence: {avg_confidence:.6f}%")
+                
+                # Show prediction distribution
+                from collections import Counter
+                pred_counts = Counter(r['prediction'] for r in successful)
+                print(f"   📋 Prediction distribution:")
+                for pred, count in pred_counts.most_common():
+                    pct = (count / len(successful)) * 100
+                    print(f"      {pred}: {count} ({pct:.1f}%)")
+                
+                if args.verbose:
+                    print(f"\n🔍 Full Results Structure:")
+                    for result in successful:
+                        print(f"   Record {result['record']}: {result}")
+            
+            return 0
+            
+        except Exception as e:
+            print(f"❌ Error loading CSV: {e}")
+            return 1
+    
+    # Handle JSON record
     try:
-        record = json.loads(args.record)
+        record = json.loads(args.input)
     except json.JSONDecodeError as e:
-        print(f"Invalid JSON record: {e}")
+        print(f"❌ Invalid JSON record: {e}")
+        print("💡 Tip: Use quotes around JSON: '{\"feature\": \"value\"}'")
         return 1
     
-    print(f"Making prediction for session {args.session_id}...")
-    
-    result = client.make_prediction(args.session_id, record)
-    prediction = result['prediction']
+    print(f"🎯 Making prediction for session {args.session_id}...")
     
-    print(f"\n🎯 Prediction:")
-    for class_name, confidence in prediction.items():
-        print(f"  {class_name}: {confidence*100:.2f}%")
-    
-    # Show top prediction
-    predicted_class = max(prediction, key=prediction.get)
-    confidence = prediction[predicted_class]
-    print(f"\n→ Predicted: {predicted_class} ({confidence*100:.1f}% confidence)")
-    
-    return 0
+    try:
+        result = client.predict(args.session_id, record)
+        
+        # Extract prediction from response
+        if 'results' in result:
+            prediction = result['results']
+            
+            print(f"\n🎯 Prediction:")
+            for class_name, confidence in prediction.items():
+                print(f"  {class_name}: {confidence*100:.2f}%")
+            
+            # Show top prediction
+            predicted_class = max(prediction, key=prediction.get)
+            confidence = prediction[predicted_class]
+            print(f"\n→ Predicted: {predicted_class} ({confidence*100:.1f}% confidence)")
+            
+        elif 'metadata' in result:
+            # Use metadata if available (server already computed highest probability)
+            predicted_class = result['metadata'].get('predicted_class', 'Unknown')
+            confidence = result['metadata'].get('confidence', 0.0)
+            
+            print(f"\n🎯 Prediction:")
+            print(f"  {predicted_class}: {confidence*100:.2f}%")
+            print(f"\n→ Predicted: {predicted_class} ({confidence*100:.1f}% confidence)")
+            
+        else:
+            raise ValueError("No prediction results found in response")
+        
+        return 0
+        
+    except Exception as e:
+        print(f"❌ Prediction failed: {e}")
+        return 1
 
 
 def cmd_status(client, args):